Os conversores analógico-digitais do tipo Delta-Sigma, também chamados de Sigma-Delta (ΣΔ), representam uma das arquiteturas de conversão mais importantes da eletrônica moderna, especialmente em aplicações que exigem alta resolução, excelente imunidade a ruído e grande precisão. Eles são amplamente utilizados em instrumentos de medição, sistemas de áudio digital, sensores industriais, balanças eletrônicas, sistemas biomédicos, aquisição de sinais lentos e equipamentos científicos.

Diferentemente de arquiteturas clássicas como Flash ADC, SAR (Successive Approximation Register) ou Pipeline ADC, o conversor Delta-Sigma não tenta converter instantaneamente o valor analógico em um número digital final. Em vez disso, ele utiliza uma estratégia baseada em superamostragem (oversampling), modelagem espectral de ruído (noise shaping) e filtragem digital para reconstruir o sinal com elevada precisão.

O surgimento dessa arquitetura está diretamente ligado às limitações físicas dos conversores tradicionais. Em sistemas de alta resolução, aumentar a precisão usando apenas comparadores extremamente precisos torna-se caro, complexo e energeticamente ineficiente. O Delta-Sigma contorna esse problema utilizando princípios matemáticos e temporais para deslocar o ruído de quantização para frequências mais altas, permitindo removê-lo posteriormente através de filtros digitais.

Uma das razões do enorme sucesso dos ADCs Delta-Sigma é que eles combinam:

• Alta resolução (16, 24 e até 32 bits efetivos em aplicações específicas)
• Excelente linearidade
• Forte rejeição a ruídos
• Baixo custo relativo em CMOS moderno
• Grande integração digital

Isso explica por que praticamente todo codec de áudio moderno, muitos sensores MEMS e diversos instrumentos industriais utilizam essa arquitetura.

Além disso, a evolução dos microcontroladores e FPGAs tornou o estudo dos conversores Delta-Sigma ainda mais relevante. Muitos microcontroladores modernos já possuem ADCs Sigma-Delta integrados, enquanto FPGAs frequentemente implementam moduladores Delta-Sigma em aplicações de aquisição de sinais, áudio e controle de potência.

Antes de entender profundamente o funcionamento interno do conversor Delta-Sigma, é importante compreender um conceito fundamental: o processo de amostragem e o problema do ruído de quantização.

O Problema da Quantização

Todo conversor analógico-digital precisa transformar uma grandeza contínua em um conjunto discreto de valores binários. Esse processo inevitavelmente introduz um erro chamado erro de quantização.

Imagine um sinal analógico variando continuamente entre 0V e 3,3V. Um ADC de baixa resolução possui poucos níveis possíveis para representar esse sinal. Assim, o valor real do sinal precisa ser arredondado para o nível digital mais próximo.

Por exemplo, um ADC de 3 bits possui apenas:

2^3 = 8

níveis possíveis de quantização.

Se o intervalo for de 0V até 3,3V, então cada degrau representará aproximadamente:

\[\frac{3.3V}{8} \approx 0.4125V\]

Isso significa que pequenas variações menores que aproximadamente 412 mV simplesmente desaparecem na conversão.

O erro introduzido pela diferença entre o valor analógico real e o valor digital representado é chamado ruído de quantização.

Em arquiteturas tradicionais, esse ruído está distribuído aproximadamente de forma uniforme ao longo do espectro de frequência. O grande diferencial do Delta-Sigma é justamente modificar essa distribuição espectral do ruído, empurrando-o para regiões de frequência onde ele pode ser removido digitalmente.

Em outras palavras:

• O ruído não desaparece
• O conversor reorganiza onde ele aparece no espectro

Esse conceito é chamado de Noise Shaping (Modelagem de Ruído), sendo um dos pilares matemáticos do conversor Delta-Sigma.

Superamostragem (Oversampling)

Outro conceito essencial no Delta-Sigma é a superamostragem.

Um ADC convencional normalmente amostra próximo da frequência mínima necessária definida pelo Teorema de Nyquist:

f_s \geq 2f_{max}

Já o Delta-Sigma trabalha com frequências de amostragem extremamente maiores que a banda útil do sinal.

Por exemplo:

• Áudio de 20 kHz
• ADC operando em vários MHz

Essa superamostragem traz duas vantagens fundamentais:

1. O ruído de quantização é espalhado em uma faixa espectral muito maior
2. O filtro digital posterior consegue remover boa parte desse ruído

Combinando:

• Oversampling
• Noise shaping
• Filtragem digital

o conversor Delta-Sigma consegue atingir resoluções extremamente elevadas usando hardware analógico relativamente simples.

Na próxima seção veremos a estrutura interna do modulador Delta-Sigma, incluindo:

• Integrador
• Comparador
• Realimentação (feedback)
• DAC interno
• Fluxo de bits do modulador
• Funcionamento temporal do laço Sigma-Delta
• Papel do filtro digital de decimação

Além disso, começaremos a comparar formalmente essa arquitetura com ADCs SAR, Flash e Pipeline.

The post Conversor Analógico Delta-Sigma (ΔΣ ADC) first appeared on MCU & FPGA.

Média Móvel Exponencial, Wiener e Kalman aplicados ao RP2040

1. Introdução — Por que filtros são decisores disfarçados

Ao longo desta série, trabalhamos com DSP embarcado aplicado, partindo do sinal bruto até decisões confiáveis em microcontroladores de recursos limitados. Em todos os artigos anteriores, um ponto ficou claro:

Nenhum sinal real é limpo.
Nenhuma decisão deve confiar em uma única amostra.

É exatamente nesse ponto que entram os filtros estatísticos.

Embora muitas vezes apresentados apenas como técnicas matemáticas, filtros como média móvel exponencial, Wiener e Kalman são, na prática, mecanismos de tomada de decisão temporal, capazes de separar:

• sinal de ruído,
• tendência de flutuação,
• informação de incerteza.

Neste artigo, vamos tratar esses filtros não como abstrações matemáticas, mas como ferramentas práticas de engenharia, aplicáveis diretamente a microcontroladores como o RP2040.

1.1 O papel dos filtros na arquitetura embarcada moderna

Em um sistema embarcado real, filtros aparecem em três papéis fundamentais:

1. Suavização
   • Reduz ruído de sensores
   • Evita decisões instáveis
2. Estimativa
   • Inferir estados não diretamente observáveis
   • Combinar modelo e medição
3. Tomada de decisão
   • Controlar histerese
   • Definir quando um evento realmente ocorreu

Nos artigos anteriores, usamos:

• EMA implicitamente (suavização de score)
• Estatística para decisão adaptativa

Agora, vamos formalizar isso conscientemente.

1.2 Ordem crescente de complexidade (e poder)

Os filtros que abordaremos seguem uma progressão natural:

Importante:
mais complexo não significa melhor.
Cada filtro resolve um tipo específico de problema.

1.3 Começando pelo mais importante: Média Móvel Exponencial (EMA)

A média móvel exponencial é, sem exagero, o filtro mais importante do firmware moderno.

Ela aparece em:

• sensores IoT,
• controle de ganhos,
• suavização de scores,
• debouncing avançado,
• aprendizado estatístico.

E, ainda assim, é frequentemente subestimada.

1.4 Conceito intuitivo da EMA

A EMA responde a uma pergunta simples:

Quanto do passado eu quero lembrar?

Ela combina:

• valor anterior filtrado
• nova amostra

Equação discreta:

\[
y[n] = y[n-1] + \alpha \big(x[n] – y[n-1]\big)
\]

Onde:

• \(x[n]\): amostra atual
• \(y[n]\): saída filtrada
• \(\alpha \in (0,1)\): taxa de resposta

Interpretação física:

• \(\alpha\) pequeno → memória longa
• \(\alpha\) grande → resposta rápida

1.5 EMA como filtro passa-baixa de primeira ordem

Embora simples, a EMA é um filtro IIR passa-baixa, com:

• 1 polo real
• estabilidade garantida
• custo O(1) por amostra

Ela elimina:

• ruído de alta frequência
• flutuações instantâneas

Sem introduzir:

• buffers grandes
• atrasos excessivos

1.6 Implementação incremental em C (base do artigo)

Começamos com a versão mais simples possível:

typedef struct {
    float y;
} ema_filter_t;

static inline void ema_init(ema_filter_t *f, float y0)
{
    f->y = y0;
}

static inline float ema_step(ema_filter_t *f, float x, float alpha)
{
    f->y += alpha * (x - f->y);
    return f->y;
}

typedef struct {
    float y;
} ema_filter_t;

static inline void ema_init(ema_filter_t *f, float y0)
{
    f->y = y0;
}

static inline float ema_step(ema_filter_t *f, float x, float alpha)
{
    f->y += alpha * (x - f->y);
    return f->y;
}

Características:

• Nenhuma alocação dinâmica
• Uma multiplicação por amostra
• Ideal para ISR ou loop rápido

1.7 Escolhendo o valor de α (engenharia, não tentativa)

Uma regra prática muito usada em firmware:

Outra forma de pensar:

• EMA ≈ média móvel de \(N \approx \frac{2}{\alpha}\) amostras

Exemplo:

• α = 0.05 → ~40 amostras efetivas

1.8 Onde a EMA falha (e por quê)

Apesar de poderosa, a EMA tem limitações claras:

• Não modela dinâmica do sistema
• Não separa ruído de sinal estatisticamente
• Não incorpora incerteza
• Não prevê o futuro

Essas limitações nos levam naturalmente aos próximos filtros.

The post Filtros Estatísticos em Sistemas Embarcados: EMA, Wiener e Kalman Aplicados ao RP2040 first appeared on MCU & FPGA.

A ideia prática em firmware é simples: você acumula N amostras do ADC em um buffer, calcula a mediana do buffer e usa esse valor como leitura filtrada. O detalhe é que ordenar tudo (por exemplo, com quicksort) custa mais do que precisamos. Para achar a mediana, basta encontrar o elemento “do meio” na ordem — e isso pode ser feito com seleção por partição, também conhecida como Quickselect.

Fórmulas: o que é a mediana (caso ímpar e par)

Considere uma janela com N amostras \(x_0, x_1, \dots, x_{N-1}\). Imagine a versão ordenada dessas amostras \(x_{(0)} \le x_{(1)} \le \dots \le x_{(N-1)}\), onde \(x_{(k)}\) é o k-ésimo menor valor.

Quando N é ímpar, a mediana é o elemento central:

\[
\mathrm{med}(x) = x_{\left(\frac{N-1}{2}\right)}
\]

Quando N é par, há duas convenções comuns. A mais usada em processamento numérico é a média dos dois centrais:

\[
\mathrm{med}(x) = \frac{ x_{\left(\frac{N}{2}-1\right)} + x_{\left(\frac{N}{2}\right)} }{2}
\]

Em ADC (inteiro), essa divisão por 2 costuma ser feita com cuidado para não estourar o tipo (por isso somamos em 32 bits e só depois dividimos).

Por que “seleção por partição” resolve melhor que ordenar tudo

Ordenar N valores tipicamente custa \(O(N \log N)\). Já o Quickselect encontra o k-ésimo menor em tempo médio (O(N)), porque ele faz o mesmo “corte” do quicksort (partição em torno de um pivô), mas só continua recursivamente/iterativamente no lado que contém o índice k. Para a mediana, você quer \(k = (N-1)/2\) (ou os dois centrais se N for par).

Para firmware, isso é valioso: menos ciclos, menos consumo, e você pode rodar a cada janela sem pesar no tempo real. Em geral, o algoritmo trabalha in-place (ele rearranja o buffer). Se você precisa preservar as amostras originais, basta copiar a janela para um buffer temporário e aplicar o Quickselect nesse temporário.

Código em C: Quickselect iterativo + mediana para ADC (uint16_t)

Abaixo vai uma implementação iterativa (evita recursão, o que é mais amigável a microcontroladores), com partição estilo Lomuto. Ela funciona bem para medianas em janelas pequenas/médias (bem típico em ADC). Está tudo comentado e pronto para colar em um projeto bare-metal/RTOS.

#include <stdint.h>
#include <stddef.h>

/**
 * @brief Troca dois elementos uint16_t.
 */
static inline void swap_u16(uint16_t *a, uint16_t *b)
{
    uint16_t t = *a;
    *a = *b;
    *b = t;
}

/**
 * @brief Particiona o array no intervalo [left, right] usando o pivô em pivot_index.
 *
 * Após a partição:
 * - todos os elementos < pivot ficam à esquerda,
 * - todos os elementos >= pivot ficam à direita,
 * - a função retorna a posição final do pivô.
 *
 * @param a Array de amostras (será rearranjado in-place).
 * @param left Índice inicial do intervalo.
 * @param right Índice final do intervalo.
 * @param pivot_index Índice do pivô escolhido.
 * @return size_t Posição final do pivô após a partição.
 */
static size_t partition_lomuto_u16(uint16_t *a, size_t left, size_t right, size_t pivot_index)
{
    const uint16_t pivot = a[pivot_index];

    // Move pivô para o final para particionar mais facilmente
    swap_u16(&a[pivot_index], &a[right]);

    size_t store = left;

    for (size_t i = left; i < right; i++)
    {
        if (a[i] < pivot)
        {
            swap_u16(&a[i], &a[store]);
            store++;
        }
    }

    // Coloca o pivô na posição final
    swap_u16(&a[store], &a[right]);
    return store;
}

/**
 * @brief Escolha simples de pivô: "mediana de três" (left, mid, right).
 *
 * Isso reduz a chance de pior caso em dados parcialmente ordenados,
 * algo comum em ADC com rampa lenta.
 */
static size_t pivot_median_of_three_u16(uint16_t *a, size_t left, size_t right)
{
    size_t mid = left + (right - left) / 2;

    uint16_t x = a[left];
    uint16_t y = a[mid];
    uint16_t z = a[right];

    // Retorna o índice da mediana entre x, y, z
    if ((x <= y && y <= z) || (z <= y && y <= x)) return mid;
    if ((y <= x && x <= z) || (z <= x && x <= y)) return left;
    return right;
}

/**
 * @brief Quickselect iterativo: encontra o k-ésimo menor elemento (0-based).
 *
 * @param a Array (será rearranjado in-place).
 * @param n Tamanho do array.
 * @param k Índice (0..n-1) do elemento desejado na ordem crescente.
 * @return uint16_t Valor do k-ésimo menor elemento.
 */
uint16_t quickselect_k_u16(uint16_t *a, size_t n, size_t k)
{
    size_t left = 0;
    size_t right = n - 1;

    while (left <= right)
    {
        size_t pivot_index = pivot_median_of_three_u16(a, left, right);
        size_t pivot_final = partition_lomuto_u16(a, left, right, pivot_index);

        if (pivot_final == k)
        {
            return a[pivot_final];
        }
        else if (k < pivot_final)
        {
            // Continua só no lado esquerdo
            if (pivot_final == 0) break; // proteção contra underflow
            right = pivot_final - 1;
        }
        else
        {
            // Continua só no lado direito
            left = pivot_final + 1;
        }
    }

    // Em condições normais não chega aqui; retorno defensivo
    return a[k];
}

/**
 * @brief Calcula a mediana de uma janela ADC (uint16_t).
 *
 * Observação importante: o Quickselect altera o array.
 * Se você precisa preservar o buffer original, passe uma cópia.
 *
 * @param window Buffer de N amostras.
 * @param n Número de amostras (N).
 * @return uint16_t Mediana (para N par, retorna a média dos dois centrais).
 */
uint16_t median_adc_u16_inplace(uint16_t *window, size_t n)
{
    if (n == 0) return 0;

    if (n & 1u)
    {
        // N ímpar: elemento central
        size_t k = (n - 1u) / 2u;
        return quickselect_k_u16(window, n, k);
    }
    else
    {
        // N par: média dos dois centrais
        size_t k1 = (n / 2u) - 1u;
        size_t k2 = (n / 2u);

        uint16_t m1 = quickselect_k_u16(window, n, k1);
        uint16_t m2 = quickselect_k_u16(window, n, k2);

        // Soma em 32 bits para evitar overflow e divide por 2
        uint32_t sum = (uint32_t)m1 + (uint32_t)m2;
        return (uint16_t)(sum / 2u);
    }
}

#include <stdint.h>
#include <stddef.h>

/**
 * @brief Troca dois elementos uint16_t.
 */
static inline void swap_u16(uint16_t *a, uint16_t *b)
{
    uint16_t t = *a;
    *a = *b;
    *b = t;
}

/**
 * @brief Particiona o array no intervalo [left, right] usando o pivô em pivot_index.
 *
 * Após a partição:
 * - todos os elementos < pivot ficam à esquerda,
 * - todos os elementos >= pivot ficam à direita,
 * - a função retorna a posição final do pivô.
 *
 * @param a Array de amostras (será rearranjado in-place).
 * @param left Índice inicial do intervalo.
 * @param right Índice final do intervalo.
 * @param pivot_index Índice do pivô escolhido.
 * @return size_t Posição final do pivô após a partição.
 */
static size_t partition_lomuto_u16(uint16_t *a, size_t left, size_t right, size_t pivot_index)
{
    const uint16_t pivot = a[pivot_index];

    // Move pivô para o final para particionar mais facilmente
    swap_u16(&a[pivot_index], &a[right]);

    size_t store = left;

    for (size_t i = left; i < right; i++)
    {
        if (a[i] < pivot)
        {
            swap_u16(&a[i], &a[store]);
            store++;
        }
    }

    // Coloca o pivô na posição final
    swap_u16(&a[store], &a[right]);
    return store;
}

/**
 * @brief Escolha simples de pivô: "mediana de três" (left, mid, right).
 *
 * Isso reduz a chance de pior caso em dados parcialmente ordenados,
 * algo comum em ADC com rampa lenta.
 */
static size_t pivot_median_of_three_u16(uint16_t *a, size_t left, size_t right)
{
    size_t mid = left + (right - left) / 2;

    uint16_t x = a[left];
    uint16_t y = a[mid];
    uint16_t z = a[right];

    // Retorna o índice da mediana entre x, y, z
    if ((x <= y && y <= z) || (z <= y && y <= x)) return mid;
    if ((y <= x && x <= z) || (z <= x && x <= y)) return left;
    return right;
}

/**
 * @brief Quickselect iterativo: encontra o k-ésimo menor elemento (0-based).
 *
 * @param a Array (será rearranjado in-place).
 * @param n Tamanho do array.
 * @param k Índice (0..n-1) do elemento desejado na ordem crescente.
 * @return uint16_t Valor do k-ésimo menor elemento.
 */
uint16_t quickselect_k_u16(uint16_t *a, size_t n, size_t k)
{
    size_t left = 0;
    size_t right = n - 1;

    while (left <= right)
    {
        size_t pivot_index = pivot_median_of_three_u16(a, left, right);
        size_t pivot_final = partition_lomuto_u16(a, left, right, pivot_index);

        if (pivot_final == k)
        {
            return a[pivot_final];
        }
        else if (k < pivot_final)
        {
            // Continua só no lado esquerdo
            if (pivot_final == 0) break; // proteção contra underflow
            right = pivot_final - 1;
        }
        else
        {
            // Continua só no lado direito
            left = pivot_final + 1;
        }
    }

    // Em condições normais não chega aqui; retorno defensivo
    return a[k];
}

/**
 * @brief Calcula a mediana de uma janela ADC (uint16_t).
 *
 * Observação importante: o Quickselect altera o array.
 * Se você precisa preservar o buffer original, passe uma cópia.
 *
 * @param window Buffer de N amostras.
 * @param n Número de amostras (N).
 * @return uint16_t Mediana (para N par, retorna a média dos dois centrais).
 */
uint16_t median_adc_u16_inplace(uint16_t *window, size_t n)
{
    if (n == 0) return 0;

    if (n & 1u)
    {
        // N ímpar: elemento central
        size_t k = (n - 1u) / 2u;
        return quickselect_k_u16(window, n, k);
    }
    else
    {
        // N par: média dos dois centrais
        size_t k1 = (n / 2u) - 1u;
        size_t k2 = (n / 2u);

        uint16_t m1 = quickselect_k_u16(window, n, k1);
        uint16_t m2 = quickselect_k_u16(window, n, k2);

        // Soma em 32 bits para evitar overflow e divide por 2
        uint32_t sum = (uint32_t)m1 + (uint32_t)m2;
        return (uint16_t)(sum / 2u);
    }
}

Como usar em um fluxo típico de ADC (janela deslizante)

Em prática embarcada, você costuma ter um buffer circular com N amostras mais recentes. Quando a janela “fecha” (por exemplo, a cada amostra ou a cada bloco DMA), você copia para um buffer temporário e calcula a mediana nele, preservando o circular.

Uma versão de uso (exemplo) ficaria assim:

#include <string.h> // memcpy

#define N  15

static uint16_t adc_ring[N];
static uint16_t tmp[N];
static size_t wr = 0;

/**
 * @brief Atualiza a janela com uma nova amostra e devolve a mediana.
 *
 * @param sample Nova leitura ADC.
 * @return uint16_t Mediana das últimas N amostras.
 */
uint16_t adc_update_and_median(uint16_t sample)
{
    adc_ring[wr] = sample;
    wr = (wr + 1u) % N;

    // Copia a janela para processar sem bagunçar o ring
    memcpy(tmp, adc_ring, sizeof(tmp));

    return median_adc_u16_inplace(tmp, N);
}

#include <string.h> // memcpy

#define N  15

static uint16_t adc_ring[N];
static uint16_t tmp[N];
static size_t wr = 0;

/**
 * @brief Atualiza a janela com uma nova amostra e devolve a mediana.
 *
 * @param sample Nova leitura ADC.
 * @return uint16_t Mediana das últimas N amostras.
 */
uint16_t adc_update_and_median(uint16_t sample)
{
    adc_ring[wr] = sample;
    wr = (wr + 1u) % N;

    // Copia a janela para processar sem bagunçar o ring
    memcpy(tmp, adc_ring, sizeof(tmp));

    return median_adc_u16_inplace(tmp, N);
}

Esse padrão é especialmente bom quando você tem ruídos impulsivos: a mediana remove “picos” isolados com eficiência sem a latência de um filtro passa-baixas forte.

Observações de engenharia para ficar “bom de firmware”

Como o Quickselect rearranja dados, o custo de memória vira uma decisão de projeto: se você pode destruir a janela, roda direto; se não pode, copie. Em microcontroladores pequenos, dá para manter um tmp[] estático do tamanho da janela. Para tempo real, prefira N pequeno (9, 15, 31) e pivô “mediana de três” como no código para reduzir casos ruins quando o sinal muda lentamente. Se você estiver usando FreeRTOS, essa função pode rodar numa tarefa de processamento após um evento do DMA, mantendo o ISR enxuto.

Se você quiser ir além, dá para combinar mediana com média: primeiro aplica mediana para “limpar” impulsos e depois uma média móvel curta para reduzir ruído branco, o que costuma ficar excelente para sensores resistivos, NTC e shunt (onde spikes de comutação aparecem).

The post Mediana em medições via ADC e o algoritmo de seleção por partição (Quickselect) first appeared on MCU & FPGA.

• Filtragem Digital, Cepstrum e Detecção Acústica em MCU
• Detecção de Assobio Humano com o Algoritmo de Goertzel no RP2040

1. Introdução — Por que combinar Goertzel com aprendizado estatístico?

Nos dois artigos anteriores desta série, exploramos duas estratégias clássicas e complementares de processamento digital de sinais em microcontroladores:

1. Séries de Taylor + Cepstrum → análise estrutural e harmônica do sinal
2. Algoritmo de Goertzel → detecção espectral dirigida e altamente eficiente

Ambas funcionam muito bem, mas compartilham uma característica importante:
a decisão final é baseada em limiares fixos.

Neste terceiro artigo, damos um passo conceitual além, mantendo o Goertzel como extrator de características espectrais, mas substituindo o decisor rígido por um modelo de aprendizado estatístico leve, adequado a MCUs como o RP2040.

O objetivo não é “colocar inteligência artificial por marketing”, mas sim responder a um problema real:

Como tornar a detecção mais robusta quando o ambiente muda, o usuário muda ou o ruído não é previsível?

1.1 O papel do Goertzel nesta nova arquitetura

É importante deixar claro desde o início:

• Goertzel não será substituído
• Não vamos rodar FFT gigante
• Não vamos usar redes neurais profundas
• Goertzel continua sendo o sensor espectral

Nesta arquitetura, o Goertzel atua como um extrator determinístico de características (features):

• Energia na frequência fundamental
• Relação entre harmônicos
• Estabilidade espectral ao longo do tempo

Esses valores passam a ser dados de entrada para um bloco estatístico que decide se o padrão observado se parece ou não com um assobio humano real.

1.2 O que entendemos aqui por “aprendizado estatístico”

Neste artigo, aprendizado estatístico não significa deep learning.

Vamos trabalhar com modelos:

• Interpretáveis
• Leves
• Computacionalmente previsíveis
• Treináveis com poucos dados

Exemplos que abordaremos ao longo do artigo:

• Média e variância adaptativas
• Distância estatística (z-score, Mahalanobis simplificada)
• Classificador linear simples
• Modelo incremental (online learning)

Tudo isso é:

• Executável em ponto flutuante simples
• Compatível com firmware bare-metal
• Determinístico em tempo real

1.3 Por que limiares fixos falham em campo

Nos artigos anteriores, usamos decisões do tipo:

• score > S_ON
• score < S_OFF

Isso funciona bem quando:

• O ambiente é estável
• O microfone é sempre o mesmo
• O usuário assobia sempre da mesma forma

Mas em campo real:

• Pessoas assobiam diferente
• Distância ao microfone muda
• Ruído de fundo varia
• Ganho analógico muda com temperatura e alimentação

Resultado:
limiar bom hoje, ruim amanhã.

O aprendizado estatístico resolve exatamente isso:

• Ele aprende o padrão típico
• Ele tolera variações naturais
• Ele se adapta lentamente ao ambiente

1.4 Visão geral da nova arquitetura

A nova cadeia de processamento será:

ADC
 └── DC-block
     └── Frame (256 amostras)
         └── Goertzel (fundamental + harmônicos)
             └── Vetor de características
                 └── Modelo estatístico adaptativo
                     └── Decisão (assobio / não assobio)
                         └── LED / evento

Comparando com o artigo anterior:

1.5 O que você terá ao final deste artigo

Ao final deste terceiro artigo da série, você terá:

• Um detector de assobio adaptativo
• Baseado em Goertzel + estatística
• Código 100% em C
• Executando em tempo real no RP2040
• Sem dependência de bibliotecas externas
• Com arquitetura reutilizável para:
  • Detecção de padrões acústicos
  • Sensores inteligentes
  • Interfaces por som
  • Pré-processamento para tinyML

Mais importante:
você entenderá como transformar DSP em dados e dados em decisão, de forma técnica.

The post Detecção de Assobio com Goertzel e Aprendizado Estatístico no RP2040 first appeared on MCU & FPGA.

1 — LPC (Linear Predictive Coding)

O que significa LPC

LPC é o acrônimo de Linear Predictive Coding (Codificação Preditiva Linear).
Trata-se de um método matemático usado para modelar sinais, especialmente sinais de fala e áudio, assumindo que cada amostra do sinal pode ser aproximada como uma combinação linear de amostras passadas.

Em termos simples:

o LPC tenta responder à pergunta
“Dado o passado recente do sinal, qual é o melhor valor para a próxima amostra?”

Essa ideia é central em processamento de fala, reconhecimento de padrões acústicos e, mais recentemente, em pipelines de extração de características cepstrais, como o LPCC.

Intuição física e de sinal

No contexto de fala (mas não limitado a ele), o LPC modela o sinal como:

• Uma fonte de excitação (ex.: vibração das cordas vocais)
• Um filtro linear (trato vocal, cavidade acústica, ou sistema ressonante)

Matematicamente, o sinal é tratado como a saída de um filtro tudo-polo (all-pole) excitado por um sinal simples.

Isso é importante porque:

• Formantes (ressonâncias) aparecem naturalmente nos polos do modelo
• O modelo é compacto, computacionalmente eficiente e estável

Modelo matemático do LPC

O sinal discreto ( x[n] ) é modelado como:

\[
x[n] = -\sum_{k=1}^{p} a_k , x[n-k] + e[n]
\]

onde:

• \( a_k \) → coeficientes LPC
• \( p \) → ordem do modelo
• \( e[n] \) → erro de predição (resíduo)

O objetivo do LPC é escolher os coeficientes \( a_k \) que minimizam a energia média do erro.

Isso leva diretamente às Equações de Yule-Walker, resolvidas normalmente pelo algoritmo de Levinson-Durbin — que veremos em código C mais à frente.

Por que o LPC é importante para LPCC

Aqui está o ponto-chave que conecta esta seção ao restante do artigo:

• LPCC (Linear Prediction Cepstral Coefficients) não existem sem LPC
• O LPC fornece:
  • Os coeficientes do filtro
  • A estrutura espectral
• O LPCC transforma esses coeficientes em um domínio cepstral, mais adequado para:
  • Reconhecimento de padrões
  • Classificação
  • Machine Learning clássico

Ou seja:

LPC modela o sistema
LPCC descreve o sistema

Implementação conceitual do LPC em C (visão geral)

Antes do código completo, o pipeline típico em C é:

1. Janela do sinal (ex.: Hamming)
2. Cálculo da autocorrelação
3. Levinson-Durbin → coeficientes LPC
4. Conversão LPC → LPCC (próxima seção futura)

Nesta seção, focamos apenas no LPC puro.

Exemplo em C — cálculo da autocorrelação

#include <stddef.h>

/**
 * Calcula a autocorrelação de um sinal
 * x      : sinal de entrada
 * N      : número de amostras
 * p      : ordem LPC
 * r      : vetor de autocorrelação (tamanho p+1)
 */
void autocorrelation(const float *x, size_t N, size_t p, float *r)
{
    for (size_t k = 0; k <= p; k++) {
        r[k] = 0.0f;
        for (size_t n = k; n < N; n++) {
            r[k] += x[n] * x[n - k];
        }
    }
}

#include <stddef.h>

/**
 * Calcula a autocorrelação de um sinal
 * x      : sinal de entrada
 * N      : número de amostras
 * p      : ordem LPC
 * r      : vetor de autocorrelação (tamanho p+1)
 */
void autocorrelation(const float *x, size_t N, size_t p, float *r)
{
    for (size_t k = 0; k <= p; k++) {
        r[k] = 0.0f;
        for (size_t n = k; n < N; n++) {
            r[k] += x[n] * x[n - k];
        }
    }
}

Esse vetor r[k] é exatamente o que alimenta o algoritmo de Levinson-Durbin, que gera os coeficientes LPC.

Observações práticas para sistemas embarcados

Do ponto de vista de firmware e IoT:

• LPC é extremamente viável em microcontroladores
• Complexidade: ( O(p^2) )
• Pode ser executado:
  • Em tempo real
  • Com DMA + buffers circulares
  • Integrado a pipelines FreeRTOS ou Zephyr

Isso explica por que LPC/LPCC ainda são relevantes mesmo em tempos de deep learning.

The post LPCC (Linear Prediction Cepstral Coefficients): Fundamentos, Algoritmos e Aplicações em Sistemas Embarcados first appeared on MCU & FPGA.

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.

Quando trabalhamos com áudio em sistemas embarcados (como um ESP32-P4), é muito comum pensar apenas em tempo e frequência: sinal no tempo, depois FFT para ver o espectro, aplicar filtros, etc. Porém, há situações em que olhar somente o espectro de magnitude não é suficiente para separar os “componentes” de interesse do sinal:

• Separar o conteúdo de excitação (por exemplo, cordas vocais ou fonte sonora) do “formante” ou ressonâncias do sistema (trato vocal, sala, caixa acústica).
• Identificar ecos ou reverberações (reflexões) embutidos no sinal.
• Estimar pitch (frequência fundamental da voz) mesmo em ambientes ruidosos ou com filtragem forte.
• Detectar características de envoltória espectral (timbre) independentemente da excitação instantânea.

A análise cepstral foi criada justamente para isso: ela “desfaz” a convolução no domínio da frequência ao transformar multiplicações em somas usando o logaritmo, e depois aplica novamente uma transformada inversa. Isso gera um novo domínio de análise – não mais tempo, nem frequência – mas o domínio da quefrequência.

Conceito intuitivo de Quefrequência

O termo “quefrequência” é um trocadilho proposital com “frequency” (frequência). A ideia é:

• No domínio da frequência, o eixo horizontal é a frequência ( f ) (Hz).
• Na análise cepstral, depois de aplicar log do espectro e uma transformada inversa, o eixo horizontal passa a ter unidade de tempo, mas não é o tempo original do sinal; é um “tempo de periodicidade” derivado da estrutura de frequência.
• Como essa variável não é exatamente o tempo do domínio original, nem a frequência, foi dado o nome de quefrequência e a unidade de queferência (em segundos ou amostras, mas interpretada como “período da estrutura espectral”).

Intuitivamente:

• Picos de periodicidade de pitch aparecem como picos em quefrequência correspondendo ao período fundamental do sinal.
• A envoltória lenta do espectro (por exemplo, os formantes da voz ou a resposta de uma sala) aparece concentrada em baixas quefrequências.
• Componentes mais “rápidos” do espectro (finas linhas espectrais, harmônicos) aparecem em quefrequências mais altas.

Isso permite “separar no eixo da quefrequência” aquilo que queremos analisar:

• Baixa quefrequência → envoltória espectral (formantes, timbre, resposta de sistema).
• Alta quefrequência → detalhes finos da excitação (harmônicos, rugosidade, etc.).

Em processamento de voz, isso tem aplicações clássicas:

• Modelagem fonte–filtro: a fala é modelada como excitação (cordas vocais ou ruído glótico) passando por um filtro (trato vocal). A análise cepstral permite separar esses dois componentes.
• Reconhecimento de fala: coeficientes cepstrais (por exemplo, MFCC – Mel Frequency Cepstral Coefficients) são onipresentes em sistemas de ASR.
• Equalização e cancelamento de eco: a estrutura de eco pode ser observada no domínio cepstral e tratada de forma mais clara em alguns cenários.

No contexto do ESP32-P4 e de sistemas embarcados em geral, a análise cepstral é interessante porque:

• Pode ser implementada em cima de FFTs já disponíveis (bibliotecas de DSP, ESP-DSP, etc.).
• É computacionalmente viável para janelas de áudio de tamanho moderado.
• Fornece uma representação compacta do sinal (poucos coeficientes cepstrais podem ser suficientes para muitos algoritmos de decisão, classificação ou detecção).

Visão global do fluxo de análise cepstral

Sem entrar ainda nos detalhes matemáticos (que virão na próxima seção), o fluxo básico é:

1. Janelação do sinal no tempo
   Pegamos um bloco de amostras \( x[n] \) (por exemplo, 256, 512 ou 1024 amostras) e aplicamos uma janela \( w[n] \) (Hann, Hamming, etc.) para reduzir descontinuidades.
2. Transformada de Fourier (FFT)
   Calculamos o espectro complexo:
   \[
   X[k] = \text{FFT}{ x[n] \cdot w[n] }
   \]
   Obtemos magnitude (|X[k]|) e fase \(\angle X[k]\).
3. Logaritmo da magnitude
   Calculamos o logaritmo \(natural ou base 10\) da magnitude:
   \[
   Y[k] = \log(|X[k]|)
   \]
   Isso transforma produtos (decorrentes da convolução no tempo) em somas no domínio espectral.
4. Transformada de Fourier inversa (IFFT)
   Fazemos a IFFT de ( Y[k] ):
   \[
   c[n] = \text{IFFT}{ Y[k] }
   \]
   O sinal \( c[n] \) é o cepstro do quadro de áudio, e o índice ( n ) agora é interpretado como quefrequência.
5. Análise dos coeficientes cepstrais
   • Coeficientes próximos de ( n = 0 ) (baixa quefrequência) descrevem a envoltória lenta do espectro.
   • Coeficientes em quefrequências maiores podem indicar periodicidade (pitch) e detalhes finos.

Na prática, em um ESP32-P4, esse fluxo pode ser implementado em tempo quase real, usando:

• DMA + I2S para adquirir áudio.
• FFT otimizada em ponto fixo ou flutuante (conforme os recursos).
• Um pipeline de janelas de áudio para extrair cepstro quadro a quadro (por exemplo, a cada 10–20 ms).

Nas próximas seções, vamos:

1. Escrever as fórmulas matemáticas formais da análise cepstral (domínio contínuo e discreto, convolução, FFT, log-espectro, IFFT, quefrequência).
2. Discutir a interpretação física e prática do cepstro e da quefrequência, com exemplos típicos em áudio.
3. Apresentar códigos em C para ESP32-P4, com:
   • Aquisição de áudio (mock ou usando I2S).
   • Cálculo da FFT, log-espectro e IFFT para obter o cepstro.
   • Extração de coeficientes de baixa quefrequência para uso em algoritmos de decisão (por exemplo, detecção de voz, pitch simplificado, ou caracterização de timbre).

2 – Fundamentos Matemáticos da Análise Cepstral e da Quefrequência

A análise cepstral nasce da necessidade de separar efeitos de convolução entre um sinal de excitação e a resposta de um sistema. Em áudio, isso aparece no modelo clássico fonte–filtro, mas o conceito é geral: sempre que um sinal ( x(t) ) resulta da convolução entre dois sinais ( s(t) ) e ( h(t) ), o cepstro ajuda a separar essas contribuições.

2.1 O ponto de partida: convolução no tempo → multiplicação na frequência

Seja um sinal:

\[
x(t) = s(t) * h(t)
\]

onde:

• \( s(t) \): excitação (por exemplo, vibrato das cordas vocais).
• \( h(t) \): filtro (por exemplo, trato vocal ou resposta de uma sala).

Pela transformada de Fourier:

\[
X(\omega) = S(\omega) \cdot H(\omega)
\]

A multiplicação complica a interpretação do espectro quando queremos isolar \( S(\omega) \) e \( H(\omega) \).
A solução clássica é aplicar logaritmo:

\[
\log |X(\omega)| = \log |S(\omega)| + \log |H(\omega)|
\]

Isto é fundamental: o log converte produtos em somas, tornando possível uma “separação” térmica entre efeitos rápidos e lentos no domínio espectral.

2.2 Cepstro como IFFT do log-espectro

A definição formal do cepstro real é:

\[
c(t) = \mathcal{F}^{-1}\left{ \log |X(\omega)| \right}
\]

O sinal \( c(t) \) não está mais no domínio do tempo original. O eixo ( t ) passa a ser interpretado como quefrequência, e sua unidade não é frequência, mas sim algo dimensionalmente equivalente ao tempo — porém não o tempo físico.

Por isso, usa-se notação humorística criada pelo grupo de Bogert (inventores do cepstro):

• tempo → quetime
• frequência → quefrequência
• espectro → espectro
• cepstro → cepstrum
• convolução → convolução
• filtro → lifter (filtro no domínio do cepstro)

No domínio discreto, para uma janela ( x[n] ), temos:

\[
X[k] = \text{FFT}{x[n]}
\]

\[
C[n] = \text{IFFT}\left{\log(|X[k]|)\right}
\]

onde:

• \( k = 0, 1, …, N-1 \) é o índice de frequência,
• \( n = 0, 1, …, N-1 \) é o índice de quefrequência.

2.3 Separação entre excitação e envoltória espectral

A interpretação prática decorre da análise de periodicidades:

• A excitação ( s(t) ), quando periódica (como voz sonora), gera um espectro composto por harmônicos espaçados.
  Esses harmônicos introduzem padrões rápidos no espectro → aparecem em quefrequências altas.
• O filtro ( h(t) ) representa a forma da garganta, microfone, sala, etc., produzindo variações lentas na magnitude espectral (formantes, equalização).
  Essas variações lentas → aparecem em quefrequências baixas.

Portanto:

\[
C[n] = C_s[n] + C_h[n]
\]

e como:

• \( C_h[n] \) está concentrado em pequenos valores de ( n ),
• \( C_s[n] \) está concentrado em valores mais altos,

fica simples isolá-los truncando ou filtrando o cepstro.

2.4 Pitch a partir da quefrequência

Se o sinal contém um período dominante \( T_0 \), sua frequência fundamental é:

\[
f_0 = \frac{1}{T_0}
\]

No domínio cepstral, surge um pico aproximadamente em:

\[
n_0 \approx \frac{T_0}{\Delta t}
\]

onde \( \Delta t = \frac{1}{f_s} \) é o período de amostragem.

Por exemplo, em voz humana, com pitch entre 80 e 300 Hz:

• \( T_0 \approx 3,3 \text{ ms a } 12,5 \text{ ms} \)
• Em um sistema com 16 kHz de amostragem: \[
  n_0 \approx [53\text{ a }200] \text{ amostras}
  \]

Assim, basta procurar o máximo do cepstro em uma faixa adequada.

2.5 Cepstro em sistemas embarcados: por que é eficiente?

A análise cepstral é muito eficiente computacionalmente porque:

• Reutiliza FFT/IFFT já comuns em DSP.
• Usa apenas operações elementares (log, magnitude, FFT inversa).
• Pode ser reduzida a poucos coeficientes (por exemplo, primeiros 12 CEPSTRAIS).

Isso torna o método adequado para o ESP32-P4, que conta com:

• Núcleos de processamento de 32 bits com boa capacidade de DSP.
• Instruções aceleradas para MACs e operações vetoriais.
• Suporte a bibliotecas otimizadas, como ESP-DSP.

3 – Interpretação Prática da Quefrequência em Áudio

A análise cepstral não é apenas uma manobra matemática elegante; ela é extremamente prática quando lidamos com sinais acústicos reais. Nesta seção, vamos interpretar o que significa observar um sinal no domínio da quefrequência e como isso permite separar componentes que, no domínio da frequência tradicional, aparecem misturados.

3.1 Separação Fonte–Filtro: o coração da análise cepstral

Em áudio — especialmente em voz e instrumentos — um modelo universal é:

\[
x(t) = s(t) * h(t)
\]

onde:

• \( s(t) \) é a excitação (cordas vocais, palheta, ruído, golpe mecânico),
• \( h(t) \) é o filtro acústico (trato vocal, corpo do instrumento, caixa acústica, reverberação).

Esse modelo implica:

\[
X(\omega) = S(\omega)\cdot H(\omega)
\]

Quando analisamos o espectro convencional, os efeitos de excitação e filtro aparecem multiplicados. O buraco que a análise cepstral preenche é justamente desmultiplicar esses efeitos — o que não é possível diretamente através da FFT, mas se torna possível usando o log-espectro + IFFT.

O que acontece no cepstro?

Após o processo:

\[
C[n] = \text{IFFT}{\log(|X[k]|)},
\]

a estrutura se reorganiza de forma surpreendente:

• Variações lentas do espectro (formantes, equalização, formato do corpo do instrumento) aparecem próximas de n = 0.
• Variações rápidas, como harmônicos resultantes de excitações periódicas, aparecem em quefrequências maiores.

É como se a análise cepstral “esticava” o espectro em um domínio onde cada tipo de efeito possui uma assinatura clara e separável.

3.2 Estimativa de Pitch (Fundamental) no Cepstro

Uma das aplicações mais conhecidas do cepstro é a detecção de pitch.

Considere um sinal periódico com período fundamental \( T_0 \). Um espectro composto por harmônicos cria uma estrutura repetitiva. O log-espectro evidencia essas repetições e a IFFT devolve um pico em:

\[
n_0 \approx \frac{T_0}{\Delta t},
\quad \Delta t = \frac{1}{f_s}.
\]

Interpretando:

• O pico ocorre aproximadamente na quefrequência que representa o período do sinal.
• Assim, basta localizar o máximo em uma janela adequada para extrair pitch.

Exemplo prático:

Para amostragem a 16 kHz e pitch de 200 Hz:

\[
T_0 = 5 \text{ ms} \quad \Rightarrow \quad n_0 \approx 80.
\]

Logo, buscar picos entre 50 e 250 amostras é suficiente para detectar a maior parte da voz humana.

Essa abordagem funciona bem mesmo quando:

• O espectro está suavizado,
• Há ruído moderado,
• O sinal sofreu filtragens/acústicas conhecidas ou não lineares.

3.3 Detecção de Envoltória Espectral (Timbre)

Os primeiros coeficientes do cepstro representam a envelopa espectral, que define o timbre de instrumentos e da voz.

Em reconhecimento de fala, isso inspira técnicas clássicas como:

• LPC (Linear Predictive Coding),
• MFCC (Mel-Frequency Cepstral Coefficients).

A ideia é simples:

• Os coeficientes de baixa quefrequência capturam a forma geral do espectro.
• Pequenos conjuntos (12 a 20 coeficientes) representam bem o timbre.

Isso se torna extremamente útil em sistemas embarcados para:

• Classificação de sons (porta batendo, voz, motor, música).
• Detecção de eventos acústicos (EDA).
• Reconhecimento de comandos por voz com baixa complexidade.

3.4 Detecção de Eco e Reverberação

Uma propriedade menos conhecida — mas muito poderosa — é a capacidade de observar ecos no domínio cepstral.

Quando um eco ocorre com atraso \( \tau \), a convolução com uma versão atrasada do sinal adiciona um componente periódico no espectro. No cepstro, isso aparece como um pico em:

\[
n_\tau \approx \frac{\tau}{\Delta t}.
\]

Exemplo:

• Um eco com 10 ms de atraso → pico na quefrequência correspondente a 10 ms.
• Uma reverberação mais longa produz uma faixa de quefrequências com energia distribuída.

Isso é útil para:

• Cancelamento de eco,
• Algoritmos de de-reverberação,
• Diagnóstico acústico (testes de salas, tubulações, painéis mecânicos).

3.5 Resumo interpretativo da quefrequência

Este mapeamento orienta como “ler” um cepstro e como projetar algoritmos que exploram o método.

4 – Implementação Prática da Análise Cepstral no ESP32-P4

Nesta seção entramos no nível operacional: como implementar, no ESP32-P4, o pipeline completo da análise cepstral — desde a captura de áudio até a obtenção do vetor de coeficientes no domínio da quefrequência.

O ESP32-P4 possui um núcleo de desempenho superior às gerações anteriores, com instruções otimizadas para DSP, permitindo executar FFT/IFFT e operações vetoriais com boa eficiência mesmo em janelas de 512 ou 1024 amostras. A biblioteca ESP-DSP facilita bastante esse processo, pois contém FFTs altamente otimizadas.

A seguir, apresento o pipeline completo e exemplos de código baseados no ESP-IDF + ESP-DSP.

4.1 Pipeline de processamento do cepstro

O processo no microcontrolador segue:

1. Capturar um quadro de áudio via I2S (1024 amostras, por exemplo).
2. Aplicar janela Hann ou Hamming.
3. Fazer FFT real → espectro complexo.
4. Obter magnitude.
5. Aplicar logaritmo.
6. Fazer IFFT para obter o cepstro.
7. Analisar quefrequências de interesse.

Representando matematicamente para ( N ) amostras:

\[
X[k] = \text{FFT}{ x[n] \cdot w[n] }
\]

\[
Y[k] = \log(|X[k]| + \epsilon)
\]

\[
C[n] = \text{IFFT}{ Y[k] }
\]

O termo \( \epsilon \) evita log(0), tipicamente \( \epsilon = 10^{-12} \).

4.2 Estrutura básica do código no ESP32-P4

A seguir um esqueleto funcional em C, com comentários detalhados e adequado ao ESP-IDF.

Inclui:

• Janela Hann
• FFT real
• Cálculo de magnitude + log
• IFFT
• Extração de pitch via busca de máximo na faixa de quefrequência

Código: Inicialização do módulo DSP

/**
 * @brief Inicializa a biblioteca ESP-DSP para FFTs
 */
static void init_dsp()
{
    // Inicializa tabelas de FFT internas.
    dsps_fft2r_init_fc32(NULL, CONFIG_DSP_MAX_FFT_SIZE);
}

/**
 * @brief Inicializa a biblioteca ESP-DSP para FFTs
 */
static void init_dsp()
{
    // Inicializa tabelas de FFT internas.
    dsps_fft2r_init_fc32(NULL, CONFIG_DSP_MAX_FFT_SIZE);
}

4.3 Aplicação da janela Hann

/**
 * @brief Aplica janela Hann ao buffer de entrada
 */
static void apply_hann(float *data, int N)
{
    for (int n = 0; n < N; n++) {
        float w = 0.5f * (1 - cosf((2 * M_PI * n) / (N - 1)));
        data[n] *= w;
    }
}

/**
 * @brief Aplica janela Hann ao buffer de entrada
 */
static void apply_hann(float *data, int N)
{
    for (int n = 0; n < N; n++) {
        float w = 0.5f * (1 - cosf((2 * M_PI * n) / (N - 1)));
        data[n] *= w;
    }
}

4.4 FFT + cálculo da magnitude + log

void compute_log_spectrum(const float *input, float *log_spec, int N)
{
    // Buffer complexo para FFT (intercalado real/imag)
    static float fft_buf[2048];

    // Copia entrada para buffer da FFT
    for (int i = 0; i < N; i++) {
        fft_buf[2*i]   = input[i]; // parte real
        fft_buf[2*i+1] = 0.0f;     // parte imaginária
    }

    // FFT real
    dsps_fft2r_fc32(fft_buf, N);
    dsps_bit_rev_fc32(fft_buf, N);

    // Calcula magnitude e log
    for (int k = 0; k < N; k++) {
        float real = fft_buf[2*k];
        float imag = fft_buf[2*k+1];
        float mag  = sqrtf(real*real + imag*imag);
        log_spec[k] = logf(mag + 1e-12f);
    }
}

void compute_log_spectrum(const float *input, float *log_spec, int N)
{
    // Buffer complexo para FFT (intercalado real/imag)
    static float fft_buf[2048];

    // Copia entrada para buffer da FFT
    for (int i = 0; i < N; i++) {
        fft_buf[2*i]   = input[i]; // parte real
        fft_buf[2*i+1] = 0.0f;     // parte imaginária
    }

    // FFT real
    dsps_fft2r_fc32(fft_buf, N);
    dsps_bit_rev_fc32(fft_buf, N);

    // Calcula magnitude e log
    for (int k = 0; k < N; k++) {
        float real = fft_buf[2*k];
        float imag = fft_buf[2*k+1];
        float mag  = sqrtf(real*real + imag*imag);
        log_spec[k] = logf(mag + 1e-12f);
    }
}

4.5 IFFT para obter o Cepstro

void compute_cepstrum(const float *log_spec, float *cep, int N)
{
    static float buf[2048];

    // Copia log-espectro para o buffer complexo
    for (int k = 0; k < N; k++) {
        buf[2*k]   = log_spec[k];
        buf[2*k+1] = 0.0f;
    }

    // IFFT
    dsps_fft2r_fc32(buf, N);
    dsps_bit_rev_fc32(buf, N);

    // Saída real do cepstro
    for (int n = 0; n < N; n++) {
        cep[n] = buf[2*n] / N; // normalização
    }
}

void compute_cepstrum(const float *log_spec, float *cep, int N)
{
    static float buf[2048];

    // Copia log-espectro para o buffer complexo
    for (int k = 0; k < N; k++) {
        buf[2*k]   = log_spec[k];
        buf[2*k+1] = 0.0f;
    }

    // IFFT
    dsps_fft2r_fc32(buf, N);
    dsps_bit_rev_fc32(buf, N);

    // Saída real do cepstro
    for (int n = 0; n < N; n++) {
        cep[n] = buf[2*n] / N; // normalização
    }
}

4.6 Extração de pitch a partir da quefrequência

O pitch aparece como o pico dominante em uma faixa de quefrequências que representa períodos possíveis da excitação.

Por exemplo, para voz humana em 16 kHz:

• pitch de 80–300 Hz → períodos entre 3,3 ms e 12,5 ms → 53–200 amostras.

/**
 * @brief Estima pitch a partir do cepstro
 *
 * @param cep      Vetor de cepstro
 * @param fs       Taxa de amostragem
 * @param N        Tamanho do cepstro
 *
 * @return Frequência fundamental estimada
 */
float estimate_pitch_from_cepstrum(const float *cep, int fs, int N)
{
    int min_q = fs / 300; // ~53
    int max_q = fs / 80;  // ~200

    int max_index = min_q;
    float max_val = cep[min_q];

    for (int n = min_q; n < max_q; n++) {
        if (cep[n] > max_val) {
            max_val   = cep[n];
            max_index = n;
        }
    }

    // período estimado
    float T0 = (float)max_index / fs;

    return 1.0f / T0;
}

/**
 * @brief Estima pitch a partir do cepstro
 *
 * @param cep      Vetor de cepstro
 * @param fs       Taxa de amostragem
 * @param N        Tamanho do cepstro
 *
 * @return Frequência fundamental estimada
 */
float estimate_pitch_from_cepstrum(const float *cep, int fs, int N)
{
    int min_q = fs / 300; // ~53
    int max_q = fs / 80;  // ~200

    int max_index = min_q;
    float max_val = cep[min_q];

    for (int n = min_q; n < max_q; n++) {
        if (cep[n] > max_val) {
            max_val   = cep[n];
            max_index = n;
        }
    }

    // período estimado
    float T0 = (float)max_index / fs;

    return 1.0f / T0;
}

4.7 Extração dos primeiros coeficientes cepstrais (para classificação)

Em muita aplicações (classificação acústica, detecção de eventos), apenas os primeiros coeficientes cepstrais são necessários.

/**
 * @brief Copia os primeiros M coeficientes do cepstro
 */
void extract_cepstral_coeffs(const float *cep, float *out, int M)
{
    for (int i = 0; i < M; i++) {
        out[i] = cep[i];
    }
}

/**
 * @brief Copia os primeiros M coeficientes do cepstro
 */
void extract_cepstral_coeffs(const float *cep, float *out, int M)
{
    for (int i = 0; i < M; i++) {
        out[i] = cep[i];
    }
}

4.8 Pipeline completo (função principal)

void process_audio_frame(float *frame, int N, int fs)
{
    static float log_spec[1024];
    static float cep[1024];

    apply_hann(frame, N);
    compute_log_spectrum(frame, log_spec, N);
    compute_cepstrum(log_spec, cep, N);

    float pitch = estimate_pitch_from_cepstrum(cep, fs, N);

    printf("Pitch estimado: %.2f Hz\n", pitch);
}

void process_audio_frame(float *frame, int N, int fs)
{
    static float log_spec[1024];
    static float cep[1024];

    apply_hann(frame, N);
    compute_log_spectrum(frame, log_spec, N);
    compute_cepstrum(log_spec, cep, N);

    float pitch = estimate_pitch_from_cepstrum(cep, fs, N);

    printf("Pitch estimado: %.2f Hz\n", pitch);
}

4.9 Observações de implementação no ESP32-P4

1. Memória
   FFT de 1024 pontos requer buffers complexos de 2048 floats → 8 KB.
   O ESP32-P4 suporta isso confortavelmente.
2. Desempenho
   Com clock adequado, é possível analisar um quadro de 1024 amostras em menos de 5 ms.
3. Precisão
   Sugere-se usar float (32 bits). Em sistemas críticos, é possível migrar para ponto fixo.
4. Aquisição de áudio real
   Basta integrar esta pipeline à captura I2S + DMA, substituindo o frame[] preenchido por dados do ADC/I2S.

5 – Conclusão e Aplicações Práticas em Sistemas Embarcados

A análise cepstral — e, em particular, a interpretação do sinal no domínio da quefrequência — é uma das ferramentas mais poderosas e versáteis no processamento moderno de áudio. Seu ponto forte é justamente possibilitar a separação matemática e prática entre efeitos que, no domínio da frequência convencional, aparecem misturados de forma inseparável.

Ao longo deste artigo, vimos que:

• O cepstro transforma convoluções em somas através da operação log-espectral + IFFT.
• Esse processo reorganiza o conteúdo espectral, permitindo distinguir excitação, resposta acústica, pitch, ecos e timbre.
• A quefrequência interpreta periodicidades espectrais (não temporais), revelando padrões profundos do sinal.
• Em voz, permite separar fonte–filtro e detectar frequência fundamental mesmo sob ruído ou filtragem.
• Em instrumentação, auxilia na detecção de defeitos, ecos estruturais, vibrações periódicas e assinaturas mecânicas.
• Em classificação de eventos acústicos, os primeiros coeficientes cepstrais são extremamente eficientes — compactos, robustos e amigáveis para algoritmos embarcados.

Do ponto de vista de implementação embarcada:

• A análise cepstral é inteiramente viável no ESP32-P4, graças às instruções DSP nativas e ao suporte da biblioteca ESP-DSP.
• Um pipeline típico com janelas de 1024 amostras pode ser processado em tempo real com folga, mesmo associado a I2S + DMA.
• O código apresentado pode servir como base para:
  • Detecção de voz (VAD);
  • Estimativa de pitch;
  • Extração de coeficientes cepstrais para classificadores;
  • Estudo de reverberações e ecos;
  • Detecção de falhas mecânicas via áudio/vibração.

A análise cepstral é especialmente adequada para sistemas embarcados modernos que precisam extrair significado de sinais sonoros complexos, mantendo consumo moderado de memória e CPU. Ela combina rigor matemático, elegância teórica e elevada eficiência prática — por isso permanece um dos pilares do processamento de áudio desde os anos 1960 até hoje.

The post Quefrequência e Análise Cepstral: Uma Introdução Prática para Sistemas Embarcados (ESP32-P4) first appeared on MCU & FPGA.