1. Introdução — Por que Goertzel?

No artigo anterior desta série, exploramos uma abordagem baseada em filtragem digital construída com Séries de Taylor, seguida pelo cálculo do cepstrum, para identificar a periodicidade característica de um assobio humano. Aquela estratégia privilegiou uma análise global do espectro, permitindo identificar a estrutura harmônica do sinal de forma robusta, mesmo em ambientes com ruído.

Neste novo artigo, damos continuidade direta a essa série, adotando uma estratégia complementar e mais enxuta: o algoritmo de Goertzel. Em vez de calcular todo o espectro via FFT, o Goertzel permite extrair seletivamente a energia de frequências específicas, tornando-o ideal para microcontroladores com recursos limitados — como o RP2040 — quando o interesse está restrito a faixas bem definidas.

O assobio humano típico apresenta uma frequência fundamental relativamente estável, geralmente entre 800 Hz e 3000 Hz, com harmônicos previsíveis. O algoritmo de Goertzel explora exatamente esse cenário:

“Eu sei qual frequência quero detectar — e só ela importa.”

1.1 Estratégia geral adotada neste artigo

A arquitetura de processamento deste artigo será:

1. Aquisição do sinal acústico (ADC do RP2040)
2. Pré-processamento simples (remoção de DC e normalização)
3. Aplicação do algoritmo de Goertzel para:
   • Frequência fundamental
   • Harmônicos selecionados
4. Construção de um critério de decisão espectral
5. Confirmação temporal (evitar falsos positivos)
6. Acionamento de um LED quando o assobio é detectado

Diferentemente do artigo anterior:

• Não calcularemos FFT
• Não calcularemos cepstrum
• Usaremos análise espectral pontual
• Menor uso de RAM e CPU
• Menor latência

Isso permite uma comparação clara entre duas filosofias de DSP embarcado:

• FFT + Cepstrum → análise estrutural
• Goertzel → análise dirigida por frequência

1.2 Quando Goertzel é a escolha correta (e quando não é)

Goertzel é uma excelente escolha quando:

• Você conhece as frequências de interesse
• O número de frequências é pequeno
• O MCU possui RAM limitada
• A latência precisa ser baixa
• O sistema é reativo (event-driven)

Goertzel NÃO é a melhor escolha quando:

• A frequência fundamental varia muito
• Você precisa analisar o espectro completo
• O sinal tem múltiplas fontes concorrentes
• A estrutura harmônica é desconhecida

Este artigo assume explicitamente o caso ideal para Goertzel:
detectar um fenômeno acústico específico e conhecido.

1.3 Relação direta com o artigo anterior

Este artigo não substitui o anterior — ele o complementa.

A ideia da série é exatamente essa: mostrar estratégias diferentes para o mesmo problema, permitindo ao engenheiro escolher conscientemente.

1.4 O que você terá ao final deste artigo

Ao final deste artigo, você terá:

• Um detector de assobio funcional
• Código 100% em C, portátil
• Execução em tempo real no RP2040
• Arquitetura reutilizável para:
  • DTMF
  • Tons de controle
  • Alarmes acústicos
  • Interfaces sonoras simples

The post Detecção de Assobio Humano com o Algoritmo de Goertzel no RP2040 first appeared on MCU & FPGA.

1 — Motivação, Visão Geral do Problema e Arquitetura da Solução

1.1 Motivação técnica

Assobios humanos possuem uma característica muito interessante do ponto de vista de processamento digital de sinais (DSP): eles apresentam uma frequência fundamental bem definida, normalmente entre 800 Hz e 3 kHz, acompanhada por harmônicas que decrescem em amplitude. Isso os torna excelentes candidatos para estudo de extração de pitch, separação espectral e detecção robusta de eventos acústicos em sistemas embarcados.

No contexto de microcontroladores como o RP2040, o desafio é duplo:

1. Executar algoritmos matematicamente consistentes com baixo custo computacional.
2. Evitar bibliotecas pesadas de DSP, favorecendo implementações determinísticas, explicáveis e portáveis.

Este artigo foi desenhado exatamente com esse espírito: mostrar que é possível construir um pipeline de detecção de assobio usando apenas matemática clássica, séries de Taylor e algoritmos fundamentais de DSP, sem FFTs complexas ou frameworks externos.

1.2 Problema a ser resolvido

O problema central pode ser descrito em três níveis:

1. Separação espectral
   O sinal do microfone contém:
   • Ruído ambiente
   • Voz humana
   • Sons impulsivos
   • O assobio propriamente dito
   Precisamos isolar a frequência fundamental do assobio e suas harmônicas.
2. Identificação confiável do assobio
   Apenas detectar energia em uma faixa de frequência não é suficiente, pois outros sons podem cair nessa banda.
   Precisamos identificar periodicidade — aqui entra o cepstrum, que trabalha no domínio da quefrência.
3. Ação física
   Após a detecção confiável:
   • Acender um LED quando um assobio é detectado
   • Apagar o LED quando o assobio desaparece

Tudo isso deve funcionar em tempo real, em um RP2040, usando a BitDogLab como plataforma de referência.

1.3 Arquitetura geral do sistema

O pipeline completo que iremos construir ao longo do artigo é o seguinte:

Microfone (ADC)
       ↓
Pré-processamento (remoção de DC)
       ↓
Filtro Digital por Séries de Taylor
(separação da fundamental e harmônicas)
       ↓
Cálculo do Cepstrum
(log + autocorrelação simplificada)
       ↓
Detecção de Pitch (assobio)
       ↓
Controle do LED (GPIO)

Microfone (ADC)
       ↓
Pré-processamento (remoção de DC)
       ↓
Filtro Digital por Séries de Taylor
(separação da fundamental e harmônicas)
       ↓
Cálculo do Cepstrum
(log + autocorrelação simplificada)
       ↓
Detecção de Pitch (assobio)
       ↓
Controle do LED (GPIO)

Cada bloco será implementado incrementalmente, de forma que:

• O código compile e funcione a cada etapa
• Possamos validar o comportamento do sistema progressivamente
• Ao final, teremos um firmware completo, funcional e didático

1.4 Por que Séries de Taylor em filtros digitais?

Normalmente, filtros digitais são apresentados como:

• IIR (Butterworth, Chebyshev, etc.)
• FIR por convolução
• FFT + máscara espectral

Aqui escolhemos Séries de Taylor por três razões estratégicas:

1. Controle matemático total
   Um filtro baseado em Taylor é, na prática, uma aproximação explícita de operadores diferenciais, o que permite entender exatamente o que está sendo implementado.
2. Eficiência em microcontroladores
   Séries truncadas resultam em:
   • Poucas multiplicações
   • Nenhuma função transcendental cara em tempo real
3. Valor didático elevado
   Esse método conecta:
   • Cálculo diferencial
   • Sistemas lineares
   • DSP clássico
     Em um único algoritmo executável em hardware real.

Mais adiante, mostraremos como aproximar respostas passa-faixa usando expansões de Taylor aplicadas a operadores discretos.

1.5 O papel do Cepstrum na detecção do assobio

Mesmo após filtrar o sinal, ainda temos um problema:
harmônicas também são periódicas, e ruídos podem enganar um detector simples.

O cepstrum resolve isso explorando uma ideia elegante:

A periodicidade no domínio do tempo vira um pico no domínio da quefrência.

Em termos práticos:

• Um assobio gera um pico claro no cepstrum
• Voz humana tende a gerar padrões mais espalhados
• Ruído branco praticamente não gera picos estáveis

Isso torna o cepstrum extremamente robusto para identificar assobios reais, mesmo em ambientes ruidosos.

The post Filtro Digital com Séries de Taylor e Cepstrum para Detecção de Assobio em RP2040 first appeared on MCU & FPGA.

A Transformada de Fourier (TF) é uma das ferramentas matemáticas mais poderosas na análise de sinais e sistemas. Ela permite converter um sinal do domínio do tempo para o domínio da frequência, revelando componentes espectrais que não são diretamente perceptíveis no tempo. Aplicações da TF vão desde o processamento digital de sinais (DSP) até física, telecomunicações, engenharia biomédica e eletrônica.

Neste artigo, exploraremos a base teórica da Transformada de Fourier, sua demonstração matemática e uma implementação completa em linguagem C, focando em clareza e didática para leitores iniciantes.

Fundamentos da Transformada de Fourier

Imagine um sinal contínuo no tempo, como uma onda sonora. Esse sinal pode ser decomposto como a soma de muitas senóides (ondas senoidais) com diferentes frequências, amplitudes e fases. A Transformada de Fourier é o processo que encontra essas senóides componentes.

Matematicamente, para um sinal contínuo x(t)x(t), a Transformada de Fourier é dada por:

\[
X(f) = \int_{-\infty}^{\infty} x(t) e^{-j 2\pi f t} \, dt
\]

Onde:

• x(t): sinal no tempo contínuo.
• X(f): espectro de frequências do sinal.
• f: frequência.
• j: unidade imaginária \((j^2 = -1)\).

A transformada inversa é dada por:

\[
x(t) = \int_{-\infty}^{\infty} X(f) e^{j 2\pi f t} \, df
\]

Ou seja, é possível reconstruir o sinal original a partir de suas componentes de frequência.

Transformada de Fourier Discreta (DFT)

Na prática, lidamos com sinais amostrados digitalmente. Para isso, usamos a versão discreta da TF: a Transformada de Fourier Discreta (DFT), definida por:

\[
X_k = \sum_{n=0}^{N-1} x_n \cdot e^{-j \frac{2\pi}{N}kn}, \quad k = 0, 1, …, N-1
\]

E a transformada inversa:

\[
x_n = \frac{1}{N} \sum_{k=0}^{N-1} X_k \cdot e^{j \frac{2\pi}{N}kn}
\]

Onde:

• \(x_n\): amostras no tempo.
• \(X_k\): componente espectral da frequência kk.
• N: número total de amostras.

Implementação em C da DFT

A seguir, apresentamos um código simples em linguagem C que calcula a DFT de um vetor de números reais. Para isso, usaremos números complexos representados por duas variáveis (parte real e imaginária).

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define PI 3.141592653589793

typedef struct {
    double real;
    double imag;
} Complex;

void DFT(double* x, Complex* X, int N) {
    for (int k = 0; k < N; k++) {
        X[k].real = 0;
        X[k].imag = 0;
        for (int n = 0; n < N; n++) {
            double angle = -2.0 * PI * k * n / N;
            X[k].real += x[n] * cos(angle);
            X[k].imag += x[n] * sin(angle);
        }
    }
}

int main() {
    int N = 8;
    double x[8] = {1, 0, -1, 0, 1, 0, -1, 0}; // Sinal de teste

    Complex* X = (Complex*)malloc(N * sizeof(Complex));

    DFT(x, X, N);

    printf("DFT Result:\n");
    for (int k = 0; k < N; k++) {
        printf("X[%d] = %.2f + %.2fi\n", k, X[k].real, X[k].imag);
    }

    free(X);
    return 0;
}

Esse código implementa diretamente a fórmula da DFT. Note que o tempo de execução cresce com \(N^2\), por isso para sinais muito longos recomenda-se usar a Transformada Rápida de Fourier (FFT), que veremos em outra seção.

A Transformada Rápida de Fourier (FFT)

Por que otimizar?

Como vimos, a DFT exige N2N^2 operações para calcular todas as NN frequências de um sinal com NN amostras. Isso pode ser extremamente lento para sinais grandes. A Transformada Rápida de Fourier (FFT) resolve esse problema ao reduzir a complexidade para Nlog⁡2NN \log_2 N, um ganho drástico em eficiência.

A FFT é uma maneira inteligente de reorganizar os cálculos da DFT, explorando simetrias matemáticas para evitar repetições desnecessárias.

Ideia por trás da FFT

A FFT mais conhecida é o algoritmo de Cooley-Tukey, que se baseia em dividir o sinal original em duas partes:

• Amostras de índices pares: \(x_0, x_2, x_4, \ldots\)
• Amostras de índices ímpares: \(x_1, x_3, x_5, \ldots\)

Essa divisão é aplicada recursivamente, até que reste apenas DFTs de tamanho 2, cuja solução é trivial.

Implementação em C da FFT (Radix-2, Recursiva)

Abaixo temos uma implementação simples e didática da FFT recursiva. Vamos assumir que o número de amostras NN seja uma potência de 2.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define PI 3.141592653589793

typedef struct {
    double real;
    double imag;
} Complex;

void fft(Complex* x, int N) {
    if (N <= 1) return;

    // Divide: cria vetores para pares e ímpares
    Complex* even = (Complex*)malloc(N/2 * sizeof(Complex));
    Complex* odd  = (Complex*)malloc(N/2 * sizeof(Complex));

    for (int i = 0; i < N/2; i++) {
        even[i] = x[2*i];
        odd[i]  = x[2*i + 1];
    }

    // Conquista: aplica FFT recursivamente
    fft(even, N/2);
    fft(odd, N/2);

    // Combina: calcula FFT final com os pares e ímpares
    for (int k = 0; k < N/2; k++) {
        double angle = -2 * PI * k / N;
        Complex twiddle = {cos(angle), sin(angle)};
        Complex t = {
            twiddle.real * odd[k].real - twiddle.imag * odd[k].imag,
            twiddle.real * odd[k].imag + twiddle.imag * odd[k].real
        };
        x[k].real       = even[k].real + t.real;
        x[k].imag       = even[k].imag + t.imag;
        x[k + N/2].real = even[k].real - t.real;
        x[k + N/2].imag = even[k].imag - t.imag;
    }

    free(even);
    free(odd);
}

int main() {
    int N = 8;

    // Sinal de entrada (parte imaginária zero)
    Complex x[8] = {
        {1,0}, {0,0}, {-1,0}, {0,0},
        {1,0}, {0,0}, {-1,0}, {0,0}
    };

    fft(x, N);

    printf("FFT Result:\n");
    for (int i = 0; i < N; i++) {
        printf("X[%d] = %.2f + %.2fi\n", i, x[i].real, x[i].imag);
    }

    return 0;
}

Comparando FFT e DFT

Aplicando a FFT a Sinais Reais de Sensores ou Áudio

Captura e amostragem de sinais reais

Sensores — como acelerômetros, termistores ou microfones — produzem sinais analógicos contínuos no tempo. Para aplicar a FFT, é necessário amostrar esses sinais com um conversor analógico-digital (ADC), obtendo um vetor de amostras igualmente espaçadas no tempo.

Esse processo gera um vetor \(x[n]\) com N amostras igualmente espaçadas por um intervalo de tempo \(T_s\), definido pela taxa de amostragem \(f_s: T_s = \frac{1}{f_s}\)

Por exemplo, uma taxa de 1000 Hz implica em uma amostra a cada 1 ms.

Pré-processamento

Antes de aplicar a FFT em um sinal real, recomenda-se:

1. Remover a média (DC): \(x[n] := x[n] – \frac{1}{N} \sum_{i=0}^{N-1} x[i]\) Isso evita picos indesejados na frequência zero (DC offset).
2. Aplicar janela (windowing): Sinais reais nem sempre são periódicos no intervalo analisado. O uso de uma janela como a de Hanning, Hamming ou Blackman suaviza as bordas do sinal e reduz o vazamento espectral (aliasing).

Exemplo prático com FFT

A seguir, adaptamos nosso código para aplicar FFT a um sinal real simulado — representando, por exemplo, a vibração medida por um acelerômetro.

Sinal de teste:

Simularemos um sinal real com duas senóides: uma de 50 Hz e outra de 120 Hz, amostradas a 1000 Hz:

\[
x[n] = \sin(2\pi 50 n T_s) + 0.5 \cdot \sin(2\pi 120 n T_s)
\]

Código em C:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define PI 3.141592653589793
#define FS 1000  // taxa de amostragem (Hz)
#define N 1024   // número de amostras (potência de 2)

typedef struct {
    double real;
    double imag;
} Complex;

// Mesma função FFT da seção anterior (recursiva)
void fft(Complex* x, int N);

// Gera um sinal real composto por duas senóides
void gerar_sinal(Complex* x) {
    for (int n = 0; n < N; n++) {
        double t = (double)n / FS;
        double s = sin(2 * PI * 50 * t) + 0.5 * sin(2 * PI * 120 * t);
        x[n].real = s;
        x[n].imag = 0;
    }
}

// Calcula módulo da FFT
double modulo(Complex c) {
    return sqrt(c.real * c.real + c.imag * c.imag);
}

int main() {
    Complex x[N];
    gerar_sinal(x);

    fft(x, N);

    printf("Frequência (Hz)\tMagnitude\n");
    for (int i = 0; i < N/2; i++) {
        double freq = (double)i * FS / N;
        double mag = modulo(x[i]) * 2.0 / N; // normaliza e dobra por ser simétrica
        printf("%.1f\t\t%.4f\n", freq, mag);
    }

    return 0;
}

Interpretando o resultado

• O vetor FFT possui NN valores complexos.
• Para sinais reais, os valores são simétricos: basta analisar os primeiros N/2 pontos.
• Cada índice ii corresponde a uma frequência:\(f_i = \frac{i \cdot f_s}{N}\)
• A magnitude |X[i]| representa a “força” (amplitude) do sinal naquela frequência.
• Os picos na magnitude indicam quais frequências dominam o sinal.

Saída esperada (parcial):

Frequência (Hz)	Magnitude
...
50.0		    1.0000
...
120.0		    0.5000
...

A Transformada Inversa de Fourier (iFFT)

O que é a iFFT?

A Transformada Inversa de Fourier, ou iFFT, permite reconstruir um sinal no tempo a partir de suas componentes de frequência.

Ela é definida como: x[n]=1N∑k=0N−1X[k]⋅ej2πNknx[n] = \frac{1}{N} \sum_{k=0}^{N-1} X[k] \cdot e^{j \frac{2\pi}{N}kn}

Ou seja, usamos os mesmos valores complexos X[k]X[k] da FFT e, com uma fórmula semelhante, obtemos novamente as amostras originais do sinal.

Quando a iFFT é usada?

• Após aplicar filtros no domínio da frequência.
• Na decodificação de sinais comprimidos (ex: MP3, JPEG).
• Para criar sons ou sinais com componentes espectrais específicas.
• Para análise de sistemas (ex: resposta impulsiva via FFT/iFFT).

Implementação em C da iFFT

A iFFT é quase idêntica à FFT — a diferença está no sinal do expoente (usa +j+j ao invés de −j-j) e na normalização final por NN.

Código: iFFT em C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define PI 3.141592653589793
#define N 8

typedef struct {
    double real;
    double imag;
} Complex;

// Função auxiliar para inverter os sinais do imaginário
void conjugar(Complex* x, int N) {
    for (int i = 0; i < N; i++)
        x[i].imag = -x[i].imag;
}

// Reaproveitamos a mesma FFT, trocando o sinal antes e depois
void fft(Complex* x, int N);  // Assume-se definida (como antes)

// iFFT com normalização
void ifft(Complex* x, int N) {
    // Conjuga
    conjugar(x, N);

    // Aplica FFT "espelhada"
    fft(x, N);

    // Conjuga novamente e divide por N
    conjugar(x, N);
    for (int i = 0; i < N; i++) {
        x[i].real /= N;
        x[i].imag /= N;
    }
}

int main() {
    Complex X[N] = {
        {0,0}, {4,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}
    };

    ifft(X, N);

    printf("Sinal reconstruído:\n");
    for (int i = 0; i < N; i++) {
        printf("x[%d] = %.4f\n", i, X[i].real);  // ignorando parte imaginária residual
    }

    return 0;
}

Sobre a parte imaginária

A parte imaginária após a iFFT de um sinal real deve ser próxima de zero (por erro numérico). Em aplicações práticas, ela é ignorada ou descartada:

double x_real = X[i].real; // Parte útil

Validação: FFT + iFFT

Um teste típico para validar seu código de FFT/iFFT é:

1. Criar um sinal x[n].
2. Aplicar FFT para obter X[k].
3. Aplicar iFFT em X[k].
4. Comparar os valores de x[n] com os reconstruídos.

Se os valores coincidirem (até erros mínimos), seu sistema está funcionando corretamente.

Aplicações avançadas

• Equalização de áudio: ajustar frequências específicas e depois aplicar iFFT.
• Cancelamento de ruído: eliminar certas frequências antes da iFFT.
• Compressão: manter só os coeficientes mais relevantes (ex: JPEG).
• Síntese sonora: construir sons pela manipulação direta do espectro.

11. Conclusão

A Transformada de Fourier é uma ferramenta indispensável para engenheiros, programadores e cientistas que trabalham com sinais, vibrações, sons, imagens ou qualquer fenômeno periódico ou oscilatório. Ela permite revelar o conteúdo de frequência de um sinal, detectar padrões invisíveis no domínio do tempo e aplicar uma vasta gama de técnicas de processamento, filtragem e reconstrução.

Neste artigo, vimos:

• A base teórica da Transformada de Fourier contínua e discreta;
• A implementação direta da DFT em linguagem C;
• A otimização via FFT (Fast Fourier Transform);
• A aplicação prática da FFT em sinais reais de sensores ou áudio;
• A reconstrução do sinal original usando a iFFT;
• E a importância da interpretação correta dos resultados espectrais.

Tudo foi feito com um olhar didático e com exemplos práticos, prontos para adaptação em sistemas embarcados, análise de sinais em tempo real ou mesmo aplicações científicas mais robustas.

Próximos passos sugeridos

Caso queira aprofundar ainda mais o estudo e uso da Transformada de Fourier, recomenda-se explorar:

• Implementações de FFT otimizadas para microcontroladores (ex: CMSIS-DSP para ARM Cortex-M);
• Visualização gráfica com Python/Matplotlib para depuração e análise;
• Filtragem digital (passa-baixas, passa-altas, notch) no domínio da frequência;
• Algoritmos FFT para sinais de tamanho não potência de 2 (Bluestein ou Mixed-Radix);
• Uso de janelas (Hamming, Blackman, etc.) para melhorar a resolução espectral.

Se quiser, posso te ajudar a gerar qualquer um desses tópicos em novas seções ou aplicações.

The post A Transformada de Fourier: Fundamentos, Demonstração e Implementação em C first appeared on MCU & FPGA.