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.

Se você é apaixonado por microcontroladores, FPGAs, sistemas embarcados, eletrônica digital, IoT, AIoT, protocolos industriais, processamento de sinais ou arquitetura de hardware, este é o seu lugar.

Criamos um espaço colaborativo no WhatsApp para reunir desenvolvedores, estudantes, pesquisadores e entusiastas que desejam evoluir juntos no universo de MCU e FPGA e todo o seu ecossistema — do firmware ao hardware, do bare-metal ao RTOS, do HDL ao edge computing.

Aqui você poderá:

• Trocar experiências práticas
• Tirar dúvidas técnicas
• Compartilhar projetos e artigos
• Discutir arquiteturas e boas práticas
• Conhecer novas ferramentas e tecnologias
• Expandir sua rede profissional

Nosso objetivo é construir uma comunidade técnica forte, colaborativa e orientada ao crescimento real.

Entre agora pelo link:
https://chat.whatsapp.com/BYXrqPHsRO5FTP7ap7X5yq

Se você acredita na força do conhecimento compartilhado, convide também seus amigos, colegas de trabalho e membros de outros grupos técnicos. Quanto mais mentes engajadas, mais rico será o aprendizado de todos.

Vamos fortalecer o ecossistema de MCU & FPGA juntos.

The post Participe em nossa comunidade no Whatsapp first appeared on MCU & FPGA.

O que são espectros e por que eles importam

Quando falamos em espectros, estamos nos referindo às diferentes faixas do espectro eletromagnético, organizadas de acordo com o comprimento de onda (λ) ou frequência da radiação. Embora o ser humano esteja limitado à percepção do espectro visível, a física nos mostra que a luz é apenas uma pequena janela de um universo muito mais amplo de interações eletromagnéticas. Cada uma dessas faixas carrega informações físicas distintas sobre os materiais, o ambiente e os fenômenos observados.

Do ponto de vista de engenharia — especialmente em sistemas embarcados, sensoriamento, visão computacional, IoT e instrumentação — compreender os espectros não é um luxo acadêmico, mas uma decisão de projeto. A escolha entre UV, Visível, NIR ou SWIR define diretamente o tipo de sensor, a óptica, o custo do sistema, o consumo energético e, principalmente, qual fenômeno físico será detectado. Em muitos casos, mudar a faixa espectral é mais eficiente do que aplicar algoritmos complexos sobre dados inadequados.

Este artigo tem como objetivo apresentar, de forma didática e técnica, o que são os principais espectros usados em aplicações modernas — UV, Visível, NIR e SWIR, além de suas combinações — explicando onde e por que cada um deve ser utilizado. A proposta não é apenas descrever faixas de comprimento de onda, mas conectar cada espectro às aplicações reais, aos sensores disponíveis e às decisões de arquitetura em sistemas embarcados e industriais.

The post Espectros Eletromagnéticos na Engenharia: UV, Visível, NIR e SWIR e Onde Usá-los 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.

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

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

Fundamentos da Transformada de Fourier

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

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

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

Onde:

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

A transformada inversa é dada por:

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

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

Transformada de Fourier Discreta (DFT)

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

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

E a transformada inversa:

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

Onde:

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

Implementação em C da DFT

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

Código C:

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

#define PI 3.141592653589793

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

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

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

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

    DFT(x, X, N);

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

    free(X);
    return 0;
}

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

A Transformada Rápida de Fourier (FFT)

Por que otimizar?

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

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

Ideia por trás da FFT

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

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

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

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

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

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

#define PI 3.141592653589793

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

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

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

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

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

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

    free(even);
    free(odd);
}

int main() {
    int N = 8;

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

    fft(x, N);

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

    return 0;
}

Comparando FFT e DFT

Aplicando a FFT a Sinais Reais de Sensores ou Áudio

Captura e amostragem de sinais reais

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

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

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

Pré-processamento

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

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

Exemplo prático com FFT

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

Sinal de teste:

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

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

Código em C:

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

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

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

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

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

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

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

    fft(x, N);

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

    return 0;
}

Interpretando o resultado

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

Saída esperada (parcial):

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

A Transformada Inversa de Fourier (iFFT)

O que é a iFFT?

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

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

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

Quando a iFFT é usada?

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

Implementação em C da iFFT

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

Código: iFFT em C

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

#define PI 3.141592653589793
#define N 8

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

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

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

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

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

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

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

    ifft(X, N);

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

    return 0;
}

Sobre a parte imaginária

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

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

Validação: FFT + iFFT

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

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

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

Aplicações avançadas

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

11. Conclusão

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

Neste artigo, vimos:

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

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

Próximos passos sugeridos

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

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

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

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