Quando o firmware precisa ser previsível (tempo real), o desenho do filtro não é só “matemático”: você escolhe estruturas e limites para garantir custo computacional constante, estado pequeno e estabilidade numérica, principalmente se você for para ponto fixo ou tiver ADC+DMA alimentando o pipeline. (Essa preocupação de arquitetura e previsibilidade é típica de projetos de tempo real.)

1) Notch discreto: o “biquad” que apaga uma frequência

Um notch digital clássico pode ser implementado como um biquad IIR (segunda ordem) com zeros exatamente na frequência que você quer cancelar e polos próximos, controlando a largura do “buraco” via fator de qualidade (Q). Quanto maior o (Q), mais estreito é o notch (ótimo para interferência tonal estável), mas maior a sensibilidade a variação de (f_0) e a quantização dos coeficientes. Em termos práticos: para hum de rede em 60 Hz, se o sinal tiver variação de frequência (rede oscilando, ou a interferência “escorregando”), um (Q) alto demais pode deixar “vazar” parte do ruído. Para tom de comutação de um inversor ou fonte chaveada, se o clock for estável, dá para usar (Q) alto e atacar de forma cirúrgica.

O biquad notch mais comum pode ser escrito como:

\[
H(z)=\frac{1 – 2\cos(\omega_0)z^{-1} + z^{-2}}{1 – 2r\cos(\omega_0)z^{-1} + r^2 z^{-2}}
\]

onde \(\omega_0=2\pi f_0/F_s\) e (r) controla a “proximidade” dos polos aos zeros (quanto mais perto de 1, mais estreito e mais profundo). Uma ligação prática entre (r) e (Q) é aproximar a largura de banda por \(BW \approx f_0/Q\) e usar \(r \approx e^{-\pi BW/F_s}\). Isso funciona muito bem para firmware porque você calcula coeficientes uma vez (ou quando \(f_0\) muda) e o processamento por amostra fica constante.

Código em C: biquad notch (float) com inicialização por \(F_s, f_0, Q\)

#include <math.h>
#include <stdint.h>

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

typedef struct {
    // Coeficientes normalizados (a0 = 1)
    float b0, b1, b2;
    float a1, a2;

    // Estados (forma direta II transposta)
    float z1, z2;
} NotchBiquad;

/**
 * @brief Inicializa um filtro notch IIR (biquad) em forma direta II transposta.
 * @param f     Ponteiro para a estrutura do filtro.
 * @param Fs    Frequência de amostragem (Hz).
 * @param f0    Frequência central do notch (Hz).
 * @param Q     Fator de qualidade (adimensional). Ex.: 10..50 típicos.
 *
 * Observação prática:
 *  - Q maior => notch mais estreito, mais sensível a variações de f0 e quantização.
 *  - Q menor => notch mais largo, remove mais “vizinhança” de frequências.
 */
static inline void notch_init(NotchBiquad *f, float Fs, float f0, float Q)
{
    const float w0 = 2.0f * (float)M_PI * (f0 / Fs);

    // Largura de banda aproximada (Hz)
    const float BW = f0 / Q;

    // Polo raio r (aprox.) -> define a largura do notch
    const float r = expf(-(float)M_PI * (BW / Fs));

    const float c = cosf(w0);

    // Numerador (zeros no círculo unitário em ±w0)
    const float b0 = 1.0f;
    const float b1 = -2.0f * c;
    const float b2 = 1.0f;

    // Denominador (polos em raio r)
    const float a0 = 1.0f;
    const float a1 = -2.0f * r * c;
    const float a2 = r * r;

    // Normaliza por a0 (a0=1 aqui, mas mantemos o padrão)
    f->b0 = b0 / a0;
    f->b1 = b1 / a0;
    f->b2 = b2 / a0;
    f->a1 = a1 / a0;
    f->a2 = a2 / a0;

    f->z1 = 0.0f;
    f->z2 = 0.0f;
}

/**
 * @brief Processa 1 amostra pelo biquad notch (DF-II Transposta).
 * @param f Estrutura do filtro.
 * @param x Amostra de entrada.
 * @return  Amostra filtrada.
 */
static inline float notch_process(NotchBiquad *f, float x)
{
    // DF-II transposta:
    // y = b0*x + z1
    // z1 = b1*x - a1*y + z2
    // z2 = b2*x - a2*y
    const float y = (f->b0 * x) + f->z1;
    const float z1 = (f->b1 * x) - (f->a1 * y) + f->z2;
    const float z2 = (f->b2 * x) - (f->a2 * y);

    f->z1 = z1;
    f->z2 = z2;
    return y;
}

#include <math.h>
#include <stdint.h>

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

typedef struct {
    // Coeficientes normalizados (a0 = 1)
    float b0, b1, b2;
    float a1, a2;

    // Estados (forma direta II transposta)
    float z1, z2;
} NotchBiquad;

/**
 * @brief Inicializa um filtro notch IIR (biquad) em forma direta II transposta.
 * @param f     Ponteiro para a estrutura do filtro.
 * @param Fs    Frequência de amostragem (Hz).
 * @param f0    Frequência central do notch (Hz).
 * @param Q     Fator de qualidade (adimensional). Ex.: 10..50 típicos.
 *
 * Observação prática:
 *  - Q maior => notch mais estreito, mais sensível a variações de f0 e quantização.
 *  - Q menor => notch mais largo, remove mais “vizinhança” de frequências.
 */
static inline void notch_init(NotchBiquad *f, float Fs, float f0, float Q)
{
    const float w0 = 2.0f * (float)M_PI * (f0 / Fs);

    // Largura de banda aproximada (Hz)
    const float BW = f0 / Q;

    // Polo raio r (aprox.) -> define a largura do notch
    const float r = expf(-(float)M_PI * (BW / Fs));

    const float c = cosf(w0);

    // Numerador (zeros no círculo unitário em ±w0)
    const float b0 = 1.0f;
    const float b1 = -2.0f * c;
    const float b2 = 1.0f;

    // Denominador (polos em raio r)
    const float a0 = 1.0f;
    const float a1 = -2.0f * r * c;
    const float a2 = r * r;

    // Normaliza por a0 (a0=1 aqui, mas mantemos o padrão)
    f->b0 = b0 / a0;
    f->b1 = b1 / a0;
    f->b2 = b2 / a0;
    f->a1 = a1 / a0;
    f->a2 = a2 / a0;

    f->z1 = 0.0f;
    f->z2 = 0.0f;
}

/**
 * @brief Processa 1 amostra pelo biquad notch (DF-II Transposta).
 * @param f Estrutura do filtro.
 * @param x Amostra de entrada.
 * @return  Amostra filtrada.
 */
static inline float notch_process(NotchBiquad *f, float x)
{
    // DF-II transposta:
    // y = b0*x + z1
    // z1 = b1*x - a1*y + z2
    // z2 = b2*x - a2*y
    const float y = (f->b0 * x) + f->z1;
    const float z1 = (f->b1 * x) - (f->a1 * y) + f->z2;
    const float z2 = (f->b2 * x) - (f->a2 * y);

    f->z1 = z1;
    f->z2 = z2;
    return y;
}

Melhores usos do notch: quando você conhece (ou mede) a frequência indesejada e ela é estreita, relativamente estável e você quer preservar quase tudo ao redor. Em instrumentação, isso aparece em leitura de shunt/ADC contaminada por rede; em áudio, hum; em controle, ressonância mecânica estreita (desde que não destrua margem de fase indevidamente); em eletrônica de potência, uma componente tonal em corrente/tensão.

2) Média sincronizada: “soma coerente” alinhada à fase

A média sincronizada (às vezes chamada de synchronous averaging, time synchronous averaging) não é “só uma média móvel”. A sacada é que você escolhe uma janela exatamente igual a um período do fenômeno repetitivo (ou múltiplos inteiros) e reinicia/alinha essa janela usando um evento de referência: um zero-cross, um pulso de encoder, um índice, ou um marcador derivado do PWM. Se você tem (N) amostras por período e faz uma média sobre (K) períodos alinhados, o componente que se repete com a mesma fase soma e cresce proporcionalmente, enquanto ruído aleatório cai como (\sqrt{K}) no RMS. Além disso, componentes que não “encaixam” naquele período tendem a se cancelar.

Em termos de filtro, isso se comporta como um filtro tipo comb (pente) extremamente eficiente para rejeitar tudo que não é coerente com o período escolhido. A diferença para um notch é que você não está mirando uma única frequência: você está favorecendo toda a forma de onda repetitiva no domínio do tempo, desde que sincronizada.

Código em C: média sincronizada por períodos (com referência externa)

A seguir vai uma implementação simples (e bem útil) para firmware: você acumula amostras de cada posição dentro do período e, a cada período completo, você atualiza a média. Isso é perfeito quando você tem um “gatilho de início de período” (por exemplo, interrupção de índice do encoder ou zero-cross).

#include <stdint.h>
#include <string.h>

typedef struct {
    uint16_t N;          // amostras por período
    uint16_t idx;        // posição atual no período [0..N-1]
    uint32_t K;          // quantos períodos já acumulados (limite/controle externo)

    // Buffers de acumulação (use int64 se seu range for grande)
    int64_t *acc;        // soma por posição
    int32_t *avg;        // média por posição (resultado)
} SyncAvg;

/**
 * @brief Inicializa a média sincronizada.
 * @param s       Estrutura.
 * @param acc     Buffer de acumulação de tamanho N (int64_t).
 * @param avg     Buffer de saída média de tamanho N (int32_t).
 * @param N       Amostras por período.
 */
static inline void syncavg_init(SyncAvg *s, int64_t *acc, int32_t *avg, uint16_t N)
{
    s->N = N;
    s->idx = 0;
    s->K = 0;
    s->acc = acc;
    s->avg = avg;

    memset(s->acc, 0, (size_t)N * sizeof(int64_t));
    memset(s->avg, 0, (size_t)N * sizeof(int32_t));
}

/**
 * @brief Deve ser chamado quando ocorre o "marcador" de início de período (ex.: zero-cross ou índice do encoder).
 *        Isso força alinhamento de fase.
 */
static inline void syncavg_period_reset(SyncAvg *s)
{
    s->idx = 0;
}

/**
 * @brief Alimenta a média sincronizada com uma amostra do ADC já alinhada ao relógio de amostragem.
 * @param s Estrutura.
 * @param x Amostra (ex.: ADC já convertido para int32).
 *
 * Funcionamento:
 *  - A cada amostra, acumula na posição idx.
 *  - Ao completar N amostras, fecha um período e atualiza avg[].
 *  - A referência de fase vem de syncavg_period_reset() (externa).
 */
static inline void syncavg_push_sample(SyncAvg *s, int32_t x)
{
    s->acc[s->idx] += (int64_t)x;
    s->idx++;

    if (s->idx >= s->N) {
        s->idx = 0;
        s->K++;

        // Atualiza a média inteira por posição (custo O(N) por período).
        // Se N for grande e seu MCU for apertado, dá para atualizar de forma incremental.
        for (uint16_t i = 0; i < s->N; i++) {
            s->avg[i] = (int32_t)(s->acc[i] / (int64_t)s->K);
        }
    }
}

#include <stdint.h>
#include <string.h>

typedef struct {
    uint16_t N;          // amostras por período
    uint16_t idx;        // posição atual no período [0..N-1]
    uint32_t K;          // quantos períodos já acumulados (limite/controle externo)

    // Buffers de acumulação (use int64 se seu range for grande)
    int64_t *acc;        // soma por posição
    int32_t *avg;        // média por posição (resultado)
} SyncAvg;

/**
 * @brief Inicializa a média sincronizada.
 * @param s       Estrutura.
 * @param acc     Buffer de acumulação de tamanho N (int64_t).
 * @param avg     Buffer de saída média de tamanho N (int32_t).
 * @param N       Amostras por período.
 */
static inline void syncavg_init(SyncAvg *s, int64_t *acc, int32_t *avg, uint16_t N)
{
    s->N = N;
    s->idx = 0;
    s->K = 0;
    s->acc = acc;
    s->avg = avg;

    memset(s->acc, 0, (size_t)N * sizeof(int64_t));
    memset(s->avg, 0, (size_t)N * sizeof(int32_t));
}

/**
 * @brief Deve ser chamado quando ocorre o "marcador" de início de período (ex.: zero-cross ou índice do encoder).
 *        Isso força alinhamento de fase.
 */
static inline void syncavg_period_reset(SyncAvg *s)
{
    s->idx = 0;
}

/**
 * @brief Alimenta a média sincronizada com uma amostra do ADC já alinhada ao relógio de amostragem.
 * @param s Estrutura.
 * @param x Amostra (ex.: ADC já convertido para int32).
 *
 * Funcionamento:
 *  - A cada amostra, acumula na posição idx.
 *  - Ao completar N amostras, fecha um período e atualiza avg[].
 *  - A referência de fase vem de syncavg_period_reset() (externa).
 */
static inline void syncavg_push_sample(SyncAvg *s, int32_t x)
{
    s->acc[s->idx] += (int64_t)x;
    s->idx++;

    if (s->idx >= s->N) {
        s->idx = 0;
        s->K++;

        // Atualiza a média inteira por posição (custo O(N) por período).
        // Se N for grande e seu MCU for apertado, dá para atualizar de forma incremental.
        for (uint16_t i = 0; i < s->N; i++) {
            s->avg[i] = (int32_t)(s->acc[i] / (int64_t)s->K);
        }
    }
}

Melhores usos da média sincronizada: quando existe um evento/clock de referência que define o período do fenômeno e você quer extrair o comportamento repetitivo com máxima imunidade a ruído. Isso aparece em análise vibroacústica sincronizada com rotação (encoder), em medição de ripple sincronizada com PWM, em leitura de sinais biomédicos quando há marcador, e em sistemas de potência quando você quer “ver” a forma média ao longo de ciclos de rede sem ser enganado por ruído ou eventos transientes fora de fase.

3) Exemplo prático combinando os dois: remover hum e depois reforçar a forma repetitiva

Em pipeline real, é comum usar notch primeiro para derrubar uma interferência tonal forte e, em seguida, média sincronizada para aumentar SNR do que restou (principalmente se o sinal útil é repetitivo e você tem referência). A ordem pode inverter dependendo do caso: se a interferência também for coerente com o mesmo período, a média pode reforçá-la, então o notch antes costuma ser mais seguro.

Abaixo, um esqueleto de uso. Imagine ADC a 4 kHz, hum em 60 Hz, e você quer fazer média sincronizada por ciclo de 60 Hz usando zero-cross (logo \(N \approx 4000/60 \approx 66\) amostras por ciclo; na prática você ajusta para manter N inteiro e usar PLL/medição de período se a rede variar).

#include <stdio.h>

// Reaproveita NotchBiquad e SyncAvg já definidos acima.

#define FS_HZ        4000.0f
#define NOTCH_F0_HZ  60.0f
#define NOTCH_Q      25.0f

#define N_SAMPLES_PER_PERIOD  66  // exemplo (depende do seu sincronismo real)

static int64_t acc_buf[N_SAMPLES_PER_PERIOD];
static int32_t avg_buf[N_SAMPLES_PER_PERIOD];

int main(void)
{
    NotchBiquad notch;
    notch_init(&notch, FS_HZ, NOTCH_F0_HZ, NOTCH_Q);

    SyncAvg s;
    syncavg_init(&s, acc_buf, avg_buf, N_SAMPLES_PER_PERIOD);

    // Exemplo: loop de aquisição (mock)
    for (int n = 0; n < 20000; n++) {
        // Em firmware real: x_raw vem do ADC (DMA buffer), e zero-cross chama syncavg_period_reset(&s)
        int32_t x_raw = (int32_t)(1000 * sinf(2.0f * (float)M_PI * 10.0f * (n / FS_HZ))); // sinal útil 10 Hz
        x_raw += (int32_t)(300 * sinf(2.0f * (float)M_PI * 60.0f * (n / FS_HZ)));        // hum 60 Hz

        // Notch (float) -> converte de volta para int32
        float y_notch = notch_process(&notch, (float)x_raw);
        int32_t y = (int32_t)y_notch;

        // Evento externo de sincronismo: aqui é só demonstração (a cada N amostras)
        if ((n % N_SAMPLES_PER_PERIOD) == 0) {
            syncavg_period_reset(&s);
        }

        // Média sincronizada
        syncavg_push_sample(&s, y);

        // Quando s.K aumenta, avg_buf contém a forma média por período
        if (s.K > 0 && (n % (N_SAMPLES_PER_PERIOD * 20)) == 0) {
            printf("K=%lu, avg[0]=%ld, avg[10]=%ld\n",
                   (unsigned long)s.K, (long)avg_buf[0], (long)avg_buf[10]);
        }
    }

    return 0;
}

#include <stdio.h>

// Reaproveita NotchBiquad e SyncAvg já definidos acima.

#define FS_HZ        4000.0f
#define NOTCH_F0_HZ  60.0f
#define NOTCH_Q      25.0f

#define N_SAMPLES_PER_PERIOD  66  // exemplo (depende do seu sincronismo real)

static int64_t acc_buf[N_SAMPLES_PER_PERIOD];
static int32_t avg_buf[N_SAMPLES_PER_PERIOD];

int main(void)
{
    NotchBiquad notch;
    notch_init(¬ch, FS_HZ, NOTCH_F0_HZ, NOTCH_Q);

    SyncAvg s;
    syncavg_init(&s, acc_buf, avg_buf, N_SAMPLES_PER_PERIOD);

    // Exemplo: loop de aquisição (mock)
    for (int n = 0; n < 20000; n++) {
        // Em firmware real: x_raw vem do ADC (DMA buffer), e zero-cross chama syncavg_period_reset(&s)
        int32_t x_raw = (int32_t)(1000 * sinf(2.0f * (float)M_PI * 10.0f * (n / FS_HZ))); // sinal útil 10 Hz
        x_raw += (int32_t)(300 * sinf(2.0f * (float)M_PI * 60.0f * (n / FS_HZ)));        // hum 60 Hz

        // Notch (float) -> converte de volta para int32
        float y_notch = notch_process(¬ch, (float)x_raw);
        int32_t y = (int32_t)y_notch;

        // Evento externo de sincronismo: aqui é só demonstração (a cada N amostras)
        if ((n % N_SAMPLES_PER_PERIOD) == 0) {
            syncavg_period_reset(&s);
        }

        // Média sincronizada
        syncavg_push_sample(&s, y);

        // Quando s.K aumenta, avg_buf contém a forma média por período
        if (s.K > 0 && (n % (N_SAMPLES_PER_PERIOD * 20)) == 0) {
            printf("K=%lu, avg[0]=%ld, avg[10]=%ld\n",
                   (unsigned long)s.K, (long)avg_buf[0], (long)avg_buf[10]);
        }
    }

    return 0;
}

Fechando a ideia: o notch discreto e a média sincronizada resolvem problemas parecidos (melhorar a qualidade do sinal), mas por “mecanismos” bem diferentes, e isso muda totalmente quando cada um é a melhor escolha. O notch é a ferramenta certa quando você conhece uma frequência indesejada bem definida e relativamente estável e quer arrancá-la do sinal com o mínimo de impacto no restante do espectro. Em firmware, isso costuma ser “hum” de 50/60 Hz, tons de chaveamento, ou uma ressonância estreita que aparece como pico bem localizado. O ponto crítico é que o notch é tão bom quanto a precisão do seu (f_0) e a escolha de (Q): se a interferência varia de frequência, um notch muito estreito deixa passar; se você alarga demais, começa a “machucar” conteúdo útil perto de (f_0). Além disso, como é um IIR, você precisa cuidar de estabilidade numérica e do formato de implementação (a forma direta II transposta tende a ser mais robusta em ponto flutuante e também costuma ser a melhor porta de entrada para depois migrar para ponto fixo).

Já a média sincronizada não é “um filtro de frequência” no sentido clássico; ela é uma técnica de extração por coerência: tudo que está alinhado com o período de referência fica mais forte, e o que não está alinhado tende a desaparecer. Por isso ela é superior quando o sinal útil é repetitivo e você tem um marcador de fase confiável, como encoder em máquina rotativa, o próprio PWM em conversores/inversores, ou zero-cross da rede. O ganho prático é enorme porque ela aumenta SNR sem precisar “inventar” um modelo espectral do ruído, mas ela também tem uma fragilidade: se o sincronismo for ruim (jitter, período variável, marcador inconsistente) a média “borrará” a forma de onda e pode até criar artefatos que parecem sinal real. Em projetos de rede elétrica, por exemplo, se você fixa (N) como “amostras por ciclo” sem acompanhar a variação real da frequência, a média começa a perder fase ao longo dos ciclos; nesse caso, ou você mede o período e ajusta (N) dinamicamente, ou você reamostra o ciclo para um grid fixo antes de acumular.

Na prática, em pipeline embarcado, uma combinação muito comum é usar notch primeiro para remover uma interferência tonal forte e depois usar média sincronizada para revelar a forma repetitiva de interesse com ruído bem mais baixo. Isso funciona especialmente bem quando a interferência não é coerente com o período que você está usando para sincronizar; se for coerente, a média pode reforçar a interferência, e aí o notch vira praticamente obrigatório antes. Se o seu sistema estiver no limite de CPU, o notch custa um número fixo e pequeno de multiplicações por amostra, enquanto a média sincronizada pode custar pouco por amostra mas “cobra” um custo por período quando você atualiza a forma média; dá para manter determinismo atualizando médias de forma incremental, ou reduzindo taxa, ou usando buffers e processamento em tarefa de menor prioridade.

The post Filtro notch discreto (notch IIR) e média sincronizada (sync averaging) 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.

Este artigo abordará uma variedade de filtros, desde os mais simples e amplamente usados, como a Média Móvel (Moving Average), até técnicas mais sofisticadas como o Filtro de Kalman. Cada técnica será apresentada com sua motivação, estrutura matemática e exemplos de implementação prática em C ou pseudo-C para microcontroladores. O objetivo é tornar o tema acessível mesmo para quem está iniciando no campo do processamento digital de sinais, mas também útil a profissionais buscando soluções eficazes e eficientes para aplicações em tempo real.

Filtro de Média Móvel

O filtro de média móvel é uma das técnicas mais simples e intuitivas para suavizar sinais ruidosos. Ele funciona como uma janela deslizante que calcula a média dos últimos N valores de entrada. Por sua simplicidade, é amplamente utilizado em sistemas embarcados com recursos computacionais limitados, como sensores de temperatura, pressão, ou leitura de sinais analógicos via ADC (Conversor Analógico-Digital).

Problema Resolvido

Sinais adquiridos por sensores frequentemente contêm flutuações indesejadas — ruídos de alta frequência — que podem dificultar decisões ou controles baseados nesses dados. O filtro de média móvel reduz essas flutuações ao suavizar o sinal, permitindo uma resposta mais estável em aplicações como termostatos, sistemas de controle de motor, ou leitura de biossensores.

Estrutura Matemática

A média móvel simples é definida pela fórmula: \[y[n] = \frac{1}{N} \sum_{i=0}^{N-1} x[n-i]\]

onde:

• y[n] é o valor filtrado no instante n,
• x[n] é a amostra de entrada no instante n,
• N é o tamanho da janela de média.

Exemplo de Código em C

#include <stdint.h>

#define WINDOW_SIZE 8

typedef struct {
    int16_t buffer[WINDOW_SIZE];
    uint8_t index;
    int32_t sum;
} MovingAverageFilter;

void initFilter(MovingAverageFilter *filter) {
    for (int i = 0; i < WINDOW_SIZE; i++)
        filter->buffer[i] = 0;
    filter->index = 0;
    filter->sum = 0;
}

int16_t updateFilter(MovingAverageFilter *filter, int16_t newValue) {
    // Subtrai o valor mais antigo da soma
    filter->sum -= filter->buffer[filter->index];
    // Armazena o novo valor
    filter->buffer[filter->index] = newValue;
    // Adiciona o novo valor à soma
    filter->sum += newValue;
    // Move o índice circular
    filter->index = (filter->index + 1) % WINDOW_SIZE;
    // Retorna a média
    return (int16_t)(filter->sum / WINDOW_SIZE);
}

Análise

Este filtro apresenta desempenho estável e implementação eficiente, sem necessidade de operações complexas como multiplicações ou divisões em ponto flutuante (exceto pela divisão final, que pode ser otimizada via deslocamento quando NNN é potência de 2). Contudo, sua resposta a variações rápidas do sinal é lenta, pois ele tende a “amortecer” transientes, tornando-o inadequado para sistemas que exigem alta reatividade.

Aplicações Típicas

• Leitura de sensores analógicos com ruído ambiente
• Suavização de variações de corrente em fontes chaveadas
• Estabilização de sinais de entrada em filtros digitais mais complexos

Filtro Exponencial (Média Móvel Exponencial)

O filtro exponencial, também conhecido como filtro de primeira ordem ou filtro IIR de coeficiente simples, é uma alternativa ao filtro de média móvel que introduz uma ponderação decrescente nas amostras anteriores. Em vez de considerar todos os valores com o mesmo peso, como no filtro de média móvel simples, ele dá mais importância às amostras mais recentes, o que permite uma resposta mais ágil às variações do sinal.

Problema Resolvido

O filtro de média móvel tradicional tende a atrasar a resposta do sistema quando a janela é grande. O filtro exponencial resolve esse problema permitindo um controle mais refinado sobre a “inércia” do filtro. Ele é particularmente útil quando é necessário suavizar sinais sem causar atrasos excessivos, como em leitura de sensores em tempo real, entrada de joysticks, ou medições de corrente em fontes chaveadas.

Estrutura Matemática

O filtro exponencial é definido pela equação de diferença: \[y[n] = \alpha \cdot x[n] + (1 – \alpha) \cdot y[n-1]\]

onde:

• y[n] é a saída filtrada no tempo nnn,
• x[n] é a entrada no tempo nnn,
• \(\alpha \in (0, 1)\) é o coeficiente de suavização: quanto mais próximo de 1, mais peso a nova entrada terá (resposta rápida); quanto mais próximo de 0, mais lenta e suave será a resposta.

Exemplo de Código em C

cCopiarEditar#include <stdint.h>

typedef struct {
    float alpha;
    float output;
} ExponentialFilter;

void initExponentialFilter(ExponentialFilter *filter, float alpha) {
    filter->alpha = alpha;
    filter->output = 0.0f;
}

float updateExponentialFilter(ExponentialFilter *filter, float input) {
    filter->output = filter->alpha * input + (1.0f - filter->alpha) * filter->output;
    return filter->output;
}

Versão para Inteiros (sem ponto flutuante)

Para microcontroladores sem FPU (Unidade de Ponto Flutuante), pode-se usar uma versão com inteiros, escalando os valores:

cCopiarEditar#include <stdint.h>

#define ALPHA_FIXED 32  // Ex: 32 representa 0.125 se o fator de escala for 256
#define SCALE 256

typedef struct {
    int32_t output;
} ExpFilterFixed;

int16_t updateExpFilterFixed(ExpFilterFixed *filter, int16_t input) {
    filter->output = (ALPHA_FIXED * input + (SCALE - ALPHA_FIXED) * filter->output) / SCALE;
    return (int16_t)filter->output;
}

Análise

O filtro exponencial possui resposta mais rápida do que a média móvel para o mesmo nível de suavização. Seu atraso de grupo é menor e o consumo de memória é reduzido, pois não é necessário armazenar buffers. Contudo, ele possui “memória infinita”, ou seja, o valor passado nunca desaparece completamente — o que pode ser uma desvantagem em alguns casos, como em detecção de transientes.

Aplicações Típicas

• Filtros de ruído para sinais de sensores IMU (Acelerômetro/Giroscópio)
• Suavização de sinais de controle em robôs e drones
• Filtros de corrente em fontes chaveadas com resposta rápida
• Modelagem de resposta térmica em sistemas com controle PID

Filtro de Média Ponderada (Janela com Pesos Customizados)

O filtro de média ponderada é uma generalização do filtro de média móvel, onde cada amostra na janela recebe um peso diferente. Essa abordagem permite maior controle sobre quais partes do sinal têm maior influência na saída filtrada. O uso de pesos permite ajustar o filtro para atender a diferentes requisitos de resposta, como reduzir o ruído sem atenuar mudanças rápidas relevantes.

Problema Resolvido

Sinais que contêm ruídos esporádicos ou picos indesejados (outliers) podem afetar significativamente a média simples. A média ponderada, ao atribuir menos peso a amostras mais antigas (ou potencialmente mais ruidosas), permite que o sistema reaja de forma mais eficiente a mudanças reais sem ser tão suscetível a ruídos momentâneos. É especialmente útil quando o sistema exige suavização, mas sem perder a capacidade de detectar transições.

Estrutura Matemática

A média ponderada é definida como: \[y[n] = \frac{\sum_{i=0}^{N-1} w_i \cdot x[n-i]}{\sum_{i=0}^{N-1} w_i}\]

onde:

• \(w_i\)​ é o peso atribuído à iii-ésima amostra da janela,
• x[n−i] é a iii-ésima amostra mais recente,
• N é o tamanho da janela.

Exemplo de pesos com ênfase nas amostras mais recentes: w={1,2,3,4}w = \{1, 2, 3, 4\}w={1,2,3,4}

Exemplo de Código em C

#include <stdint.h>

#define WINDOW_SIZE 4

typedef struct {
    int16_t buffer[WINDOW_SIZE];
    uint8_t index;
} WeightedAverageFilter;

const uint8_t weights[WINDOW_SIZE] = {1, 2, 3, 4}; // pesos: mais recente tem maior peso

int16_t updateWeightedFilter(WeightedAverageFilter *filter, int16_t newValue) {
    filter->buffer[filter->index] = newValue;
    filter->index = (filter->index + 1) % WINDOW_SIZE;

    int32_t weightedSum = 0;
    int32_t weightTotal = 0;
    uint8_t idx = filter->index;

    for (uint8_t i = 0; i < WINDOW_SIZE; i++) {
        idx = (idx == 0) ? WINDOW_SIZE - 1 : idx - 1;
        weightedSum += filter->buffer[idx] * weights[i];
        weightTotal += weights[i];
    }

    return (int16_t)(weightedSum / weightTotal);
}

Análise

O filtro de média ponderada oferece maior flexibilidade que a média móvel simples, com custo computacional ligeiramente superior. Ele é eficaz para eliminar ruídos do tipo “espeto” (spike noise) e ao mesmo tempo manter a capacidade de rastrear tendências. Sua eficiência depende da escolha apropriada dos pesos — os quais podem ser lineares, exponenciais ou customizados para a aplicação.

Aplicações Típicas

• Suavização de sinais de sensores em ambientes ruidosos
• Pré-processamento de sinais em sistemas de classificação (ex: ECG, EMG)
• Estabilização de leituras em interfaces homem-máquina (joysticks, sliders, etc.)
• Leitura de sinais analógicos sujeitos a distorções temporárias

Filtro Mediano (Median Filter)

O filtro mediano é uma técnica não linear de processamento de sinais especialmente eficaz na remoção de ruídos impulsivos, como picos isolados (outliers) que podem ocorrer em medições físicas. Diferentemente da média móvel, ele não suaviza gradualmente o sinal, mas substitui o valor central de uma janela de amostras pela mediana — o valor que está no meio quando os dados são ordenados. Isso o torna ideal para preservar bordas e transições bruscas enquanto elimina ruídos esporádicos.

Problema Resolvido

Em sistemas embarcados que realizam medições sujeitas a interferências eletromagnéticas, conexões instáveis ou saltos ocasionais de leitura (por exemplo, sensores de distância ultrassônicos, sensores de corrente em ambientes industriais ou dados de visão computacional embarcada), a presença de picos pode prejudicar decisões e controles. O filtro mediano elimina essas perturbações preservando a integridade do sinal real.

Estrutura Matemática

Para uma janela de tamanho NNN, o filtro ordena as amostras e seleciona a mediana: \[y[n] = \text{median}(x[n – (N-1)/2], …, x[n], …, x[n + (N-1)/2])\]

Onde:

• y[n] é a saída filtrada,
• x[n] é a amostra no tempo nnn,
• A mediana é o valor central da sequência ordenada.

Exemplo de Código em C (Janela de 5 Amostras)

#include <stdint.h>

#define WINDOW_SIZE 5

typedef struct {
    int16_t buffer[WINDOW_SIZE];
    uint8_t index;
} MedianFilter;

void insertValue(MedianFilter *filter, int16_t value) {
    filter->buffer[filter->index] = value;
    filter->index = (filter->index + 1) % WINDOW_SIZE;
}

int compare(const void *a, const void *b) {
    return (*(int16_t*)a - *(int16_t*)b);
}

int16_t getMedian(MedianFilter *filter) {
    int16_t temp[WINDOW_SIZE];
    for (int i = 0; i < WINDOW_SIZE; i++)
        temp[i] = filter->buffer[i];

    qsort(temp, WINDOW_SIZE, sizeof(int16_t), compare);
    return temp[WINDOW_SIZE / 2];
}

Uso Típico

cCopiarEditarMedianFilter filter = {{0}, 0};

void loop() {
    int16_t newSample = read_adc();
    insertValue(&filter, newSample);
    int16_t cleanValue = getMedian(&filter);
    // Use cleanValue no controle ou visualização
}

Análise

Embora seja mais robusto a ruídos extremos, o filtro mediano tem maior custo computacional do que os filtros baseados em média. O uso de qsort() pode ser otimizado com algoritmos específicos para mediana de 3, 5 ou 7 valores, comuns em sistemas embarcados. Ele não distorce o sinal original em regiões com variação suave e é muito eficaz para rejeitar ruídos impulsivos. No entanto, seu uso não é adequado para sistemas que exigem filtragem de ruído gaussiano ou precisão em pequenas variações.

Aplicações Típicas

• Sensores ultrassônicos ou infravermelhos com ruído espúrio
• Processamento de imagem (eliminação de pixels corrompidos)
• Sensores analógicos de baixo custo (temperatura, corrente, tensão)
• Filtragem de sinais biológicos (ex: ECG, EMG) em sistemas embarcados

Filtro de Kalman

O Filtro de Kalman é um algoritmo matemático sofisticado para estimar o estado de um sistema dinâmico a partir de medições ruidosas. Ele é amplamente utilizado em sistemas embarcados para fusão sensorial (como em IMUs), navegação, robótica e controle adaptativo. Ao contrário dos filtros tradicionais, o Kalman considera não só os valores observados, mas também as incertezas associadas tanto ao modelo quanto às medições, fazendo previsões e correções iterativas.

Problema Resolvido

Em muitos sistemas embarcados, as medições de sensores apresentam ruído, e o modelo do sistema também pode ser incerto. O filtro de Kalman resolve esse problema ao estimar o “verdadeiro estado” do sistema — mesmo que ele não seja diretamente observável — usando uma abordagem estatística baseada em modelos. É ideal para casos em que múltiplas fontes de dados devem ser integradas (por exemplo, acelerômetro + giroscópio) ou quando o sistema sofre variações lentas mas importantes.

Estrutura Matemática (Kalman 1D)

O modelo básico de um sistema linear com ruído aditivo é:

Modelo de estado: \[\hat{x}_{k|k-1} = \hat{x}_{k-1|k-1}\]

Atualização da incerteza: \[P_{k|k-1} = P_{k-1|k-1} + Q\]

Ganho de Kalman: \[K_k = \frac{P_{k|k-1}}{P_{k|k-1} + R}\]

Atualização com medição \(z_k\)​: \[\hat{x}_{k|k} = \hat{x}_{k|k-1} + K_k (z_k – \hat{x}_{k|k-1})\]\[P_{k|k} = (1 – K_k) P_{k|k-1}\]

Onde:

• \(\hat{x}\): estimativa do estado
• P: incerteza da estimativa
• Q: variância do ruído do processo
• R: variância do ruído de medição
• K: ganho de Kalman

Exemplo de Código em C (Kalman 1D)

typedef struct {
    float x;     // Estado estimado
    float p;     // Incerteza da estimativa
    float q;     // Variância do processo
    float r;     // Variância da medição
    float k;     // Ganho de Kalman
} KalmanFilter;

void initKalman(KalmanFilter *kf, float q, float r, float p, float initial_value) {
    kf->q = q;
    kf->r = r;
    kf->p = p;
    kf->x = initial_value;
}

float updateKalman(KalmanFilter *kf, float measurement) {
    // Predição
    kf->p = kf->p + kf->q;

    // Atualização
    kf->k = kf->p / (kf->p + kf->r);
    kf->x = kf->x + kf->k * (measurement - kf->x);
    kf->p = (1 - kf->k) * kf->p;

    return kf->x;
}

Análise

O filtro de Kalman é altamente eficiente, com custo computacional linear, sendo perfeitamente viável em microcontroladores de 32 bits (como Cortex-M). Sua força está em sua capacidade de combinar medições ruidosas com previsões baseadas em modelos, gerando uma estimativa mais precisa do que qualquer medição individual. Ele também pode ser estendido para sistemas multivariados (Kalman Multidimensional) e sistemas não-lineares (Filtro de Kalman Estendido).

Aplicações Típicas

• Fusão de sensores (Ex: acelerômetro + giroscópio + magnetômetro)
• Rastreamento de posição e velocidade (GPS com odometria)
• Controle de sistemas com estados não diretamente observáveis
• Estimativas adaptativas de variáveis físicas em fontes chaveadas (tensão, corrente, temperatura)

Filtro de Kalman Estendido (Extended Kalman Filter – EKF)

O Filtro de Kalman Estendido (EKF) é uma extensão do Filtro de Kalman tradicional voltada a sistemas não-lineares. Em vez de assumir que o sistema e o modelo de medição são lineares, o EKF utiliza uma aproximação local por meio da linearização com séries de Taylor, aplicando a lógica do Kalman sobre uma versão linearizada do sistema.

Problema Resolvido

Muitos sistemas físicos reais possuem comportamentos não-lineares: medição de ângulos, sensores de corrente baseados em campo magnético (como Hall), sistemas com dinâmica de rotação ou filtros para sensores de posição em robótica. O Filtro de Kalman tradicional não pode lidar corretamente com não-linearidades. O EKF permite aplicar as ideias do Kalman em sistemas que possuem modelos descritos por funções arbitrárias.

Estrutura Matemática (Resumo)

Dado um sistema modelado por: \[x_k = f(x_{k-1}, u_{k-1}) + w_{k-1}\]\[z_k = h(x_k) + v_k\]

Onde:

• \(f(\cdot)\): modelo de transição de estado (não-linear)
• \(h(\cdot)\): modelo de observação (não-linear)
• w e v: ruídos de processo e medição (gaussianos)

A linearização é feita por meio das matrizes Jacobianas:

• \(F_k = \frac{\partial f}{\partial x}\)​, avaliada em \(\hat{x}_{k-1}\)
• \(H_k = \frac{\partial h}{\partial x}\), avaliada em \(\hat{x}_{k|k-1}\)

Ciclo do EKF

1. Predição: \[\hat{x}_{k|k-1} = f(\hat{x}_{k-1}, u_{k-1})\] \[\[P_{k|k-1} = F_k P_{k-1} F_k^T + Q\]
2. Atualização: \[K_k = P_{k|k-1} H_k^T (H_k P_{k|k-1} H_k^T + R)^{-1}\]\[\hat{x}_{k} = \hat{x}_{k|k-1} + K_k (z_k – h(\hat{x}_{k|k-1}))\]\[P_k = (I – K_k H_k) P_{k|k-1}\]

Exemplo de Aplicação: Estimativa de Ângulo com Sensor de Giro

// Modelo simplificado do EKF aplicado a sensor de ângulo com giroscópio
float x = 0;   // ângulo estimado
float p = 1;
float q = 0.01; // ruído do processo
float r = 0.1;  // ruído da medição

float ekf_update(float z, float gyroRate, float dt) {
    // Predição
    x += gyroRate * dt;      // f(x) = x + w*dt
    p += q;

    // Jacobiano H = 1 para h(x) = x (medição direta)
    float k = p / (p + r);   // Kalman Gain
    x += k * (z - x);        // Atualização
    p = (1 - k) * p;

    return x;
}

Análise

O EKF é uma solução poderosa, mas exige maior capacidade computacional devido ao cálculo de derivadas (Jacobianas) e multiplicações matriciais. Sua precisão depende fortemente da qualidade das aproximações lineares — erros de modelagem ou suposições ruins podem degradar a estimativa. Ainda assim, o EKF é amplamente usado em sistemas embarcados modernos com suporte matemático básico (por exemplo, ARM Cortex-M4 com FPU).

Aplicações Típicas

• Navegação de robôs móveis (composição entre odometria e GPS)
• Estimativa de atitude (roll/pitch/yaw) com IMU em drones
• Rastreamento de posição em braços robóticos com sensores não-lineares
• Previsão de corrente em inversores com sensores indutivos

Filtro de Partículas (Particle Filter)

O Filtro de Partículas, também conhecido como Filtro de Monte Carlo, é um método de estimação baseado em probabilidade que utiliza conjuntos de amostras (partículas) para representar a distribuição de probabilidade de um estado. Ele é especialmente útil para sistemas altamente não-lineares e não-gaussianos, onde técnicas como o Filtro de Kalman Estendido se tornam imprecisas ou instáveis.

Problema Resolvido

Muitos sistemas embarcados modernos operam em ambientes ruidosos e incertos, com múltiplas fontes de erro e modelos complexos — como mapeamento e localização (SLAM), rastreamento visual ou fusão de sensores com ruídos assimétricos. Nesses casos, não é possível assumir uma única média e variância (como no Kalman), sendo necessário representar a estimativa como uma distribuição completa. O filtro de partículas resolve isso ao simular muitas hipóteses (partículas) e atualizá-las com base nas evidências.

Princípio de Funcionamento

Cada partícula representa uma possível estimativa do estado. A cada iteração:

1. Propagação (Predição):
   Cada partícula é atualizada segundo o modelo de movimento (com ruído).
2. Atualização de Peso:
   Cada partícula é ponderada com base na probabilidade de gerar a medição observada.
3. Reamostragem:
   Partículas com maior peso têm mais chances de serem mantidas; partículas com baixo peso são descartadas.

O estado estimado é a média ponderada das partículas.

Exemplo Simplificado (1D) em C

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

#define NUM_PARTICLES 100

typedef struct {
    float x;
    float weight;
} Particle;

Particle particles[NUM_PARTICLES];

void init_particles(float initial_guess) {
    for (int i = 0; i < NUM_PARTICLES; i++) {
        particles[i].x = initial_guess + ((rand() % 100) / 100.0f - 0.5f);  // ruído inicial
        particles[i].weight = 1.0f / NUM_PARTICLES;
    }
}

float gaussian(float mu, float sigma, float x) {
    float coeff = 1.0f / sqrtf(2.0f * M_PI * sigma * sigma);
    float expo = expf(-0.5f * ((x - mu) * (x - mu)) / (sigma * sigma));
    return coeff * expo;
}

void update_particles(float control_input, float measurement, float process_noise, float measurement_noise) {
    float weight_sum = 0.0f;

    // Predição e atualização de peso
    for (int i = 0; i < NUM_PARTICLES; i++) {
        // modelo de movimento: x = x + u + ruído
        particles[i].x += control_input + ((rand() % 100) / 100.0f - 0.5f) * process_noise;

        // probabilidade da medição atual com base na posição da partícula
        particles[i].weight = gaussian(particles[i].x, measurement_noise, measurement);
        weight_sum += particles[i].weight;
    }

    // Normalização dos pesos
    for (int i = 0; i < NUM_PARTICLES; i++) {
        particles[i].weight /= weight_sum;
    }

    // Reamostragem (simples)
    Particle new_particles[NUM_PARTICLES];
    for (int i = 0; i < NUM_PARTICLES; i++) {
        float r = (float)rand() / RAND_MAX;
        float sum = 0.0f;
        for (int j = 0; j < NUM_PARTICLES; j++) {
            sum += particles[j].weight;
            if (sum >= r) {
                new_particles[i] = particles[j];
                break;
            }
        }
    }

    // Atualiza o conjunto
    for (int i = 0; i < NUM_PARTICLES; i++) {
        particles[i] = new_particles[i];
    }
}

float estimate() {
    float est = 0.0f;
    for (int i = 0; i < NUM_PARTICLES; i++) {
        est += particles[i].x * particles[i].weight;
    }
    return est;
}

Análise

O Filtro de Partículas oferece uma capacidade superior de lidar com múltiplas hipóteses, ruídos não-gaussianos e observações ambíguas. Entretanto, seu custo computacional é elevado, exigindo muitas amostras e operações de reamostragem. Ainda assim, com otimizadores e simplificações, ele pode ser implementado em sistemas embarcados ARM Cortex-M com uso eficiente de memória e tempo. O principal desafio é o ajuste correto da modelagem probabilística.

Aplicações Típicas

• Navegação e Localização (SLAM) em robótica e drones
• Rastreamento visual de objetos com câmeras embarcadas
• Sistemas biomédicos com sinais altamente ruidosos
• Inferência probabilística em dispositivos IoT com múltiplos sensores

Filtro de Wiener

O Filtro de Wiener é uma técnica de filtragem estatística projetada para produzir uma estimativa ótima de um sinal desejado com base em suas correlações com o ruído e com o próprio sinal. É amplamente usado em aplicações que exigem restauração de sinais, como recuperação de áudio, imagem e sinais digitais degradados por canais ruidosos. No contexto embarcado, pode ser aplicado a sinais de sensores em que a estatística do ruído é relativamente conhecida ou estimável.

Problema Resolvido

Sinais reais são frequentemente corrompidos por ruído aditivo que pode ser modelado estocasticamente. Enquanto os filtros de média móvel e Kalman trabalham com aproximações pontuais ou suposições simplificadas, o Filtro de Wiener é ótimo no sentido de minimizar o erro quadrático médio (MSE) entre o sinal real e a saída filtrada. Ele é ideal para situações onde se conhece ou pode estimar a estatística (auto e cruz-correlações) do sinal e do ruído.

Estrutura Matemática (Wiener 1D)

O filtro de Wiener tem como solução ótima (discreta e causal): \[H(\omega) = \frac{S_{xx}(\omega)}{S_{xx}(\omega) + S_{nn}(\omega)}\]

onde:

• \(H(\omega)\): resposta em frequência do filtro
• \(S_{xx}(\omega)\): densidade espectral de potência do sinal
• \(S_{nn}(\omega)\): densidade espectral de potência do ruído

Na forma discreta e implementável, pode ser expresso como: \[y[n] = \sum_{k=0}^{N-1} h[k] \cdot x[n – k]\]

Os coeficientes h[k] são obtidos resolvendo um sistema de equações baseado nas autocorrelações do sinal e na função cruzada entre entrada e saída desejada.

Exemplo de Código em C (Forma simplificada com estimativa empírica)

#include <stdint.h>
#include <string.h>

#define N 8 // tamanho do filtro

void estimate_wiener_coeffs(const float *signal, const float *desired, float *coeffs, int len) {
    float R[N][N] = {0}; // matriz de autocorrelação
    float P[N] = {0};    // vetor de correlação cruzada

    // Construir R e P
    for (int i = 0; i < len - N; i++) {
        for (int j = 0; j < N; j++) {
            for (int k = 0; k < N; k++) {
                R[j][k] += signal[i + j] * signal[i + k];
            }
            P[j] += desired[i] * signal[i + j];
        }
    }

    // Resolver sistema linear R * h = P (poderia usar Gauss-Jordan ou LU)
    // Aqui simplificado como uma solução direta apenas para casos didáticos
    for (int i = 0; i < N; i++) {
        coeffs[i] = P[i] / (R[i][i] + 1e-6f); // simplificação para exemplo
    }
}

float apply_wiener_filter(const float *input, const float *coeffs) {
    float output = 0.0f;
    for (int i = 0; i < N; i++) {
        output += coeffs[i] * input[i];
    }
    return output;
}

Nota: Este exemplo é didático. Em aplicações reais, o sistema R⋅h=PR \cdot h = PR⋅h=P deve ser resolvido com métodos numéricos estáveis (ex: decomposição de Cholesky ou métodos iterativos).

Análise

O Filtro de Wiener é ótimo em contextos onde se conhece a estatística do sinal e ruído, mas é limitado por sua dependência desses parâmetros. Sua implementação completa pode ser pesada para microcontroladores de baixo desempenho, mas versões simplificadas, ou estimativas precomputadas, são perfeitamente viáveis em sistemas embarcados com uso constante de sinais similares.

Aplicações Típicas

• Recuperação de áudio embarcado (remoção de ruído de fundo)
• Filtragem de sinais digitais em telecomunicações embarcadas
• Processamento de imagem embarcada (ex: remoção de borrões ou granulação)
• Detecção de falhas em sensores com comportamento repetitivo (ex: sensores industriais)

Ao longo dos capítulos anteriores, exploramos uma ampla gama de filtros aplicáveis ao processamento de sinais em sistemas embarcados, desde técnicas simples baseadas em médias até algoritmos probabilísticos e estatísticos avançados. Cada filtro oferece vantagens e limitações, dependendo da natureza do sinal, do ruído presente e dos recursos computacionais disponíveis.

Comparação Geral dos Filtros

Recomendações Práticas

• Se o seu sistema embarcado for simples e tiver baixa potência computacional, comece com filtros como média móvel, exponencial ou mediano.
• Se você precisa de suavização adaptativa e preditiva, e possui sensores com ruído gaussiano, o Filtro de Kalman é altamente recomendado.
• Em sistemas com modelos não-lineares complexos (ex: giroscópio + acelerômetro), o Filtro de Kalman Estendido é a solução natural.
• Quando o sistema apresenta múltiplas hipóteses simultâneas ou incertezas complexas, como em navegação ou SLAM, o Filtro de Partículas se destaca, desde que haja recursos computacionais adequados.
• Para aplicações onde você conhece a estatística do ruído e sinal, e quer obter a melhor estimativa possível com base nessa modelagem, o Filtro de Wiener é a escolha teórica ideal.

Encerramento

Filtros são ferramentas essenciais no arsenal do engenheiro de sistemas embarcados. Dominar seus fundamentos, limitações e aplicações permite construir sistemas mais robustos, confiáveis e eficientes, independentemente da área de atuação — automação, robótica, IoT, biomédica ou aeroespacial.

The post Filtros para Processamento de Sinais em Sistemas Embarcados: Do Básico ao Avançado first appeared on MCU & FPGA.