Visualizador de Espectro de Áudio FHT – Construa um Display LED de Áudio Impressionante
Componentes e Materiais Necessários
| Componente | Quantidade | Observações |
|---|---|---|
| Arduino Nano R3 | 1 | |
| Matriz RGB WS2812B 8X32 | 1 | |
| Resistor 4.75k ohm | 3 | |
| Resistor 100k ohm | 2 | |
| Resistor 10k ohm | 2 | |
| Resistor 390 ohm (Through Hole) | 1 | |
| Diodo 1N4007 – Alta Tensão, Alta Corrente | 1 | Um 1N4004 também serve |
| Capacitor 100 nF | 2 | |
| Capacitor 1000 µF | 1 | |
| Chave Pushbutton 12mm SparkFun | 2 | Ou dois botões de painel se planeja colocar o circuito em uma caixa |
| Placa de protótipo genérica 4x6 cm | 1 | |
| Plug PCB Estéreo RCA Fêmea | 1 |
Ferramentas e Máquinas Necessárias
- Ferro de solda (genérico)
- Cabo de Áudio Jack 3.5mm para Conector Estéreo RCA
Sobre este Projeto
A Biblioteca Arduino FHT
O FHT faz exatamente o mesmo trabalho do mais conhecido FFT, mas diferentemente deste, usa apenas dados reais, enquanto o FFT trabalha com dados complexos. Portanto, o FHT usa metade da potência de processamento e metade da memória do sistema.
Esta biblioteca usa um único array para amostragem de dados em vez de dois — um para valores reais e outro para valores imaginários, usado pela biblioteca FFT. Também simplifica cálculos matemáticos complexos evitando loops com cálculos logarítmicos de ponto flutuante complexos e, em vez disso, usa algumas tabelas numéricas.
A desvantagem é que ele sempre retorna metade dos valores do tamanho do array usado para realizar a amostragem, o que leva a uma certa perda de resolução e precisão nas duas extremidades da faixa de áudio. No entanto, no caso específico, não precisamos desenvolver um instrumento de medição, mas um gadget simples — não precisamos de precisão extrema, apenas precisamos acender alguns LEDs no ritmo da música.
Claro que este não é o lugar certo para discutir o modo de operação da biblioteca FHT. Quem quiser se aprofundar pode consultar o site Open Music Lab, onde encontrará toda a documentação necessária para entender os truques usados, a explicação detalhada das várias funções e alguns exemplos genéricos já escritos para Arduino.
A biblioteca FFT é rápida, tão rápida que foi necessário inserir um delay no código para reduzir o flicker. Você notará imediatamente o resultado final: o display é muito mais rápido e responsivo que a versão que usa a biblioteca FFT, que muitas vezes parecia atrasada em relação à música. O menor uso de recursos do sistema permitiu adicionar algumas linhas de código para gerenciar funções adicionais.
A Nova Versão
O projeto é idêntico à versão anterior, então quem já fez a anterior só precisa adicionar um botão e um resistor de 10K e atualizar o código.
Além da implementação da biblioteca FHT, esta versão tem as seguintes funções adicionais:
- tem um botão adicional para ajuste de brilho;
- permite salvar configurações de cor e brilho na EEPROM para recarregá-las na próxima vez que for ligado;
- exibe o nível de configurações de cor e brilho quando os botões são pressionados e na inicialização (pode ser desabilitado).
Código
Versão do Código FHT
/* Copyright (c) 2020 Janux
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
Based on an original project for the MAX72xx LED matrix and FFT lib made from Shajeeb.
Configuration settings section based on work of Ragnar Ranøyen Homb from Norvegian Creation.
*/
#define LIN_OUT 1 // Saída linear de magnitude FHT
#define FHT_N 128 // Define AMOSTRAS para FHT, Deve ser potência de 2
#include <FHT.h>
#define xres 32 // Número total de colunas no display, deve ser <= AMOSTRAS/2
#define yres 8 // Número total de linhas no display
#define ledPIN 6 // pino de saída para controlar LEDs
#define NUM_LEDS (xres * yres) // total de LEDs na Matriz
#include <Adafruit_NeoPixel.h>
#define colorPIN 5 // pino para mudar cor do LED
#define brightnessPIN 10 // pino para mudar brilho
byte displaycolor = 0; // valor de cor padrão
byte brightness = 1; // nível de brilho padrão
#include <EEPROM.h>
#define CONFIG_START 32 // Local de início na memória
#define CONFIG_VERSION "VER01" // Versão da configuração
typedef struct {
char version[6];
byte displaycolor;
byte brightness;
} configuration_type;
configuration_type CONFIGURATION = { CONFIG_VERSION, displaycolor, brightness };
byte yvalue;
int peaks[xres];
byte state = HIGH; // leitura atual do pino de entrada
byte previousState = LOW; // leitura anterior do pino de entrada
unsigned long lastDebounceTime = 0; // último momento que o pino de saída foi alternado
unsigned long debounceDelay = 100; // tempo de debounce; aumente se a saída oscilar
byte data_avgs[xres]; // Array para amostragem
// Parâmetro 1 = número de LEDs na matriz
// Parâmetro 2 = número do pino
// Parâmetro 3 = flags de tipo de pixel, some conforme necessário:
// NEO_KHZ800 800 KHz bitstream (maioria produtos NeoPixel c/WS2812 LEDs)
// NEO_KHZ400 400 KHz (clássico 'v1' (não v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels ligados para bitstream GRB (maioria produtos NeoPixel)
// NEO_RGB Pixels ligados para bitstream RGB (v1 FLORA pixels, não v2)
Adafruit_NeoPixel pixel = Adafruit_NeoPixel(NUM_LEDS, ledPIN, NEO_GRB + NEO_KHZ800);
// Filtro EQ
byte eq[32] = {
60, 65, 70, 75, 80, 85, 90, 95, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100, 100, 100, 100, 100, 100, 100, 115, 125, 140, 160, 185, 200, 200, 200
};
bool EQ_ON = true; // defina false para desativar eq
// Defina 5 conjuntos de cores para LEDs, 0 para cor personalizada única
byte colors[][8] = {
{170, 160, 150, 140, 130, 120, 1, 1},
{1, 5, 10, 15, 20, 25, 90, 90},
{90, 85, 80, 75, 70, 65, 1, 1},
{90, 90, 90, 30, 30, 30, 1, 1},
{170, 160, 150, 140, 130, 120, 110, 0}
};
// Defina caracteres para exibir configurações
byte charBitmap[] = {
0x1C, 0x10, 0x10, 0x10, 0x10, 0x1C,
0x08, 0x18, 0x08, 0x08, 0x08, 0x1C,
0x0C, 0x12, 0x04, 0x08, 0x10, 0x1E,
0x0C, 0x12, 0x02, 0x06, 0x12, 0x0C,
0x10, 0x10, 0x10, 0x14, 0x1E,
0x04, 0x1E, 0x10, 0x1E, 0x02, 0x12, 0x0C,
0x1E, 0x10, 0x10, 0x1E,
0x12, 0x1E, 0x1E, 0x02, 0x04, 0x08, 0x08, 0x08, 0x0C,
0x12, 0x0C, 0x12, 0x12, 0x0C,
0x1C, 0x12, 0x1C, 0x12, 0x12, 0x1C
};
void setup() {
pixel.begin(); // inicializa Matriz de LED
// Inicia operações FFT
ADCSRA = 0b11100101; // define ADC para modo free running e pre-scaler para 32 (0xe5)
ADMUX = 0b00000000; // usa pino A0 e referência de tensão externa
// Lê dados de configuração da EEPROM
if (loadConfig()) {
displaycolor = CONFIGURATION.displaycolor;
brightness = CONFIGURATION.brightness;
}
// Define brilho carregado da EEPROM
pixel.setBrightness(brightness * 24 + 8);
// Mostra configuração atual na inicialização
// mude true para false se não quiser isso
showSettings(3, true);
}
void loop() {
while (1) {
// reduz jitter
Sampling(); // Biblioteca FHT usa apenas um array de dados
RearrangeFHT(); // reorganiza resultado FHT para corresponder ao nº de colunas do display
SendToDisplay(); // envia para display conforme valor medido
colorChange(); // verifica se botão pressionado para mudar cor
brightnessChange(); // verifica se botão pressionado para mudar brilho
delay(10); // delay para reduzir flickering (FHT é rápido demais :D)
}
}
void Sampling() {
for (int i = 0; i < FHT_N; i++) {
while (!(ADCSRA & 0x10)); // aguarda ADC completar conversão atual (bit ADIF setado)
ADCSRA = 0b11110101; // limpa bit ADIF para que ADC possa fazer próxima operação (0xf5)
// Bit ADLAR é 0, então os 10 bits dos registradores de dados ADC estão alinhados à direita
byte m = ADCL; // busca dados adc
byte j = ADCH;
int value = (j << 8) | m; // forma em um int
value -= 0x0200; // forma em um int com sinal
value <<= 6; // forma em um int assinado de 16 bits
fht_input[i] = value / 8; // copia para array de entrada fht após compressão
}
// ++ início processo de dados FHT -+-+--+-+--+-+--+-+--+-+--+-+--+-+-
fht_window(); // janela dos dados para melhor resposta de frequência
fht_reorder(); // reordena dados antes de fazer o fht
fht_run(); // processa dados no fht
fht_mag_lin(); // pega a saída do fht
}
void RearrangeFHT() {
// FHT retorna valor real usando apenas um array
// após chamar fht_mag_lin() os valores das amostras estão nas
// primeiras posições FHT_N/2 do array fht_lin_out[]
int step = (FHT_N / 2) / xres;
int c = 0;
for (int i = 0; i < (FHT_N / 2); i += step) {
data_avgs[c] = 0;
for (int k = 0; k < step; k++) {
data_avgs[c] = data_avgs[c] + fht_lin_out[i + k]; // magnitude de saída linear
}
data_avgs[c] = data_avgs[c] / step; // salva valor médio
c++;
}
}
void SendToDisplay() {
for (int i = 0; i < xres; i++) {
if (EQ_ON) data_avgs[i] = data_avgs[i] * (float)(eq[i]) / 100; // aplica filtro eq
data_avgs[i] = constrain(data_avgs[i], 0, 80); // define valores máx e mín para buckets 0-80
data_avgs[i] = map(data_avgs[i], 0, 80, 0, yres); // remapeia valores médios para yres 0-8
yvalue = data_avgs[i];
peaks[i] = peaks[i] - 1; // decai em um nível
if (yvalue > peaks[i]) peaks[i] = yvalue; // salva pico se > pico anterior
yvalue = peaks[i]; // escolhe pico para exibir
setColumn(i, yvalue); // desenha colunas
}
pixel.show(); // mostra coluna
}
// Acende LEDs da coluna x de acordo com valor y
void setColumn(byte x, byte y) {
int led, i;
for (i = 0; i < yres; i++) {
led = GetLedFromMatrix(x, i); // recupera LED atual por coordenadas x,y
if (peaks[x] > i) {
switch (displaycolor) {
case 4:
if (colors[displaycolor][i] == 0) {
// mostra cor personalizada com valor zero no array
pixel.setPixelColor(led, 255, 255, 255); // branco
} else {
// cor padrão definida no array colors
pixel.setPixelColor(led, Wheel(colors[displaycolor][i]));
}
break;
case 5:
// muda cor por coluna
pixel.setPixelColor(led, Wheel(x * 16));
break;
case 6:
// muda cor por linha
pixel.setPixelColor(led, Wheel(i * y * 3));
break;
case 7:
// muda cor por... país :D
// Bandeira Itália
// if (x < 11) pixel.setPixelColor(led, 0, 255, 0);
// if (x > 10 && x < 21) pixel.setPixelColor(led, 255, 255, 255);
// if (x > 20) pixel.setPixelColor(led, 255, 0, 0);
// Estrelas e listras
if (i < yres - 2) {
if (x & 0x01) {
pixel.setPixelColor(led, 0, 0, 255);
} else {
pixel.setPixelColor(led, 255, 0, 0);
}
} else {
pixel.setPixelColor(led, 255, 255, 255);
}
break;
default:
// cores de exibição definidas no array color
pixel.setPixelColor(led, Wheel(colors[displaycolor][i]));
} // END SWITCH
} else {
// Apaga LEDs
pixel.setPixelColor(led, pixel.Color(0, 0, 0));
}
}
}
//================================================================
// Calcula número do LED por coordenadas x,y
// válido para WS2812B com layout serpentina colocado horizontalmente
// e LED zero no canto inferior direito (conector DIN no lado direito)
// valor de entrada: x= 0 a xres-1 , y= 0 a yres-1
// retorna número do LED de 0 a NUM_LED
//================================================================
int GetLedFromMatrix(byte x, byte y) {
int led;
x = xres - x - 1;
if (x & 0x01) {
// Colunas ímpares aumentam para trás
led = ((x + 1) * yres - y - 1);
} else {
// Colunas pares aumentam normalmente
led = ((x + 1) * yres - yres + y);
}
return constrain(led, 0, NUM_LEDS);
}
//================================================================
void colorChange() {
int reading = digitalRead(colorPIN);
if (reading == HIGH && previousState == LOW && millis() - lastDebounceTime > debounceDelay) {
displaycolor++;
if (displaycolor > 7) displaycolor = 0;
showSettings(1, true); // defina false se não quiser isso
saveConfig();
lastDebounceTime = millis();
}
previousState = reading;
}
void brightnessChange() {
int reading = digitalRead(brightnessPIN);
if (reading == HIGH && previousState == LOW && millis() - lastDebounceTime > debounceDelay) {
brightness++;
if (brightness > 7) brightness = 0;
pixel.setBrightness(brightness * 24 + 8);
showSettings(2, true); // defina false se não quiser isso
saveConfig();
lastDebounceTime = millis();
}
previousState = reading;
}
// Utilitário do sketch de demonstração Adafruit Neopixel
// Insira um valor 0 a 255 para obter um valor de cor.
// As cores são uma transição R - G - B - de volta a R.
unsigned long Wheel(byte WheelPos) {
WheelPos = 255 - WheelPos;
if (WheelPos < 85) {
return pixel.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
if (WheelPos < 170) {
WheelPos -= 85;
return pixel.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
WheelPos -= 170;
return pixel.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
// carrega o que está na EEPROM para a CONFIGURATION local se for uma configuração válida
int loadConfig() {
if (EEPROM.read(CONFIG_START + 0) == CONFIG_VERSION[0] &&
EEPROM.read(CONFIG_START + 1) == CONFIG_VERSION[1] &&
EEPROM.read(CONFIG_START + 2) == CONFIG_VERSION[2] &&
EEPROM.read(CONFIG_START + 3) == CONFIG_VERSION[3] &&
EEPROM.read(CONFIG_START + 4) == CONFIG_VERSION[4]) {
// carrega (sobrescreve) a struct de configuração local
for (unsigned int i = 0; i < sizeof(CONFIGURATION); i++) {
*((char*)&CONFIGURATION + i) = EEPROM.read(CONFIG_START + i);
}
return 1; // retorna 1 se config carregado
}
return 0; // retorna 0 se config NÃO carregado
}
// salva a CONFIGURATION na EEPROM
void saveConfig() {
CONFIGURATION.displaycolor = displaycolor;
CONFIGURATION.brightness = brightness;
for (unsigned int i = 0; i < sizeof(CONFIGURATION); i++)
EEPROM.write(CONFIG_START + i, *((char*)&CONFIGURATION + i));
}
// 1 exibe nível de cor, 2 exibe nível de brilho, 3 ambos
void showSettings(byte num, bool show) {
if (show) {
pixel.clear();
if (num == 1 || num == 3) {
drawChar(0, 0);
drawChar(displaycolor + 1, 5);
}
if (num == 2 || num == 3) {
drawChar(9, xres - 9);
drawChar(brightness + 1, xres - 4);
}
delay(1000);
pixel.clear();
}
}
// Desenha caracteres personalizados
void drawChar(byte val, byte pos) {
for (int x = 4; x >= 0; x--) {
for (int y = 5; y >= 0; y--) {
if ((charBitmap[val * 6 + 5 - y] >> x) & 0x01) {
pixel.setPixelColor(GetLedFromMatrix(4 - x + pos, y + 1), Wheel((pos > 10) * 170));
pixel.show();
}
}
}
}
// by Janux®, Última versão em 28/06/2020.
Esquemáticos


Processo de manufatura
- Analisador de Espectro de Áudio Arduino 32 Bandas — Display Linear e Pseudo-Log
- Alerta Inteligente de Sede para Plantas – Sensor DIY para Hidratação Ideal
- Relógio de Palavras em Italiano com Arduino Nano, NeoPixel, LCD e RTC
- Medidor kWh Confiável com Sigfox e Arduino MKR Fox 1200
- Monitor de Temperatura com Bluetooth usando Arduino Nano
- Fechadura por Gestos Sem Toque: Acesso Seguro com APDS-9960 e Arduino
- Companion IC: Relógio, Ohmímetro, Capacímetro e Testador de Diodos com Arduino Nano
- Kit Adaptador USB-MIDI para Arduino Micro/Leonardo – Lista Completa de Peças
- Circuito de Entrada Analógica Isolada para Arduino
- Teste de Tempo de Reação Preciso com Arduino UNO