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

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

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

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

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

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

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

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

O Problema da Quantização

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

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

Por exemplo, um ADC de 3 bits possui apenas:

2^3 = 8

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

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

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

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

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

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

Em outras palavras:

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

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

Superamostragem (Oversampling)

Outro conceito essencial no Delta-Sigma é a superamostragem.

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

f_s \geq 2f_{max}

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

Por exemplo:

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

Essa superamostragem traz duas vantagens fundamentais:

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

Combinando:

• Oversampling
• Noise shaping
• Filtragem digital

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

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

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

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

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

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

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

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

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

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

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

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

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

1.1 O papel dos filtros na arquitetura embarcada moderna

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

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

Nos artigos anteriores, usamos:

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

Agora, vamos formalizar isso conscientemente.

1.2 Ordem crescente de complexidade (e poder)

Os filtros que abordaremos seguem uma progressão natural:

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

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

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

Ela aparece em:

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

E, ainda assim, é frequentemente subestimada.

1.4 Conceito intuitivo da EMA

A EMA responde a uma pergunta simples:

Quanto do passado eu quero lembrar?

Ela combina:

• valor anterior filtrado
• nova amostra

Equação discreta:

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

Onde:

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

Interpretação física:

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

1.5 EMA como filtro passa-baixa de primeira ordem

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

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

Ela elimina:

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

Sem introduzir:

• buffers grandes
• atrasos excessivos

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

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

typedef struct {
    float y;
} ema_filter_t;

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

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

typedef struct {
    float y;
} ema_filter_t;

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

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

Características:

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

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

Uma regra prática muito usada em firmware:

Outra forma de pensar:

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

Exemplo:

• α = 0.05 → ~40 amostras efetivas

1.8 Onde a EMA falha (e por quê)

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

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

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

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

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.

Introdução

Quando você coloca uma IMU (Unidade de Medição Inercial) como MPU6050, MPU9250 ou qualquer combinação de acelerômetro e giroscópio dentro de um projeto embarcado, você acaba esbarrando cedo ou tarde na mesma pergunta: “como eu represento a orientação do meu objeto no espaço de um jeito que eu consiga calcular inclinação, compensar gravidade, integrar rotações ao longo do tempo e ainda não destruir a estabilidade numérica do firmware?”. É aí que entram três famílias de representações que parecem concorrentes, mas na prática se complementam: ângulos de Euler (roll, pitch, yaw), vetores de orientação (por exemplo, matriz de rotação ou pares de vetores base do corpo) e quaternions.

Ângulos de Euler são intuitivos e ótimos para interfaces humanas: “inclinei 10° para frente”, “girei 30° no eixo Z”. O problema é que eles carregam armadilhas matemáticas quando você precisa acumular rotações ou passar por certas combinações de ângulos, especialmente o famoso gimbal lock (perda de um grau de liberdade). Vetores de orientação e matrizes de rotação são muito diretos do ponto de vista geométrico: você literalmente descreve para onde apontam os eixos do corpo no referencial do mundo, e isso é excelente para transformar vetores (como gravidade, aceleração e magnetismo) entre referenciais; em contrapartida, matrizes exigem mais operações, precisam ser re-ortogonalizadas para não “entortar” com erro numérico e ocupam mais memória.

Quaternions entram como uma representação que, apesar de menos intuitiva à primeira vista, é extremamente eficiente e robusta para integrar rotações com giroscópio, evitar gimbal lock e manter estabilidade numérica com um custo computacional baixo o suficiente para microcontroladores. Na prática, muita gente usa quaternions “por dentro” do filtro (Madgwick, Mahony, EKF etc.) e converte para Euler “por fora” quando precisa exibir ângulos ou configurar limites.

Nas próximas seções, eu vou construir esse entendimento em camadas: primeiro ângulos de Euler e suas relações trigonométricas, depois vetores/matrizes de orientação (com a leitura geométrica do que está acontecendo), e em seguida quaternions, mostrando como eles representam rotação, como compor rotações e como converter entre as formas. Em cada conceito eu vou demonstrar em C, com código comentado, como: (1) representar a orientação, (2) atualizar essa orientação com incrementos de rotação, e (3) extrair ângulos e também aplicar a orientação para separar aceleração linear da gravidade (o passo que faz “movimento” ficar mensurável a partir do acelerômetro).

The post Quaternions, Ângulos de Euler e Matrizes de Rotação: Guia Completo para Sistemas Embarcados e IMUs first appeared on MCU & FPGA.

Um jeito prático de pensar é: primeiro você decide o que quer preservar (variações lentas? degraus rápidos? picos curtíssimos devem sumir?), depois você escolhe um filtro com custo computacional adequado ao MCU e ao seu sampling rate (taxa de amostragem). Em projetos embarcados, isso normalmente vira uma combinação simples e robusta: um filtro de mediana para “estouros” (spikes) + um passa-baixas leve (IIR de 1ª ordem) para suavizar o jitter. A ideia de encapsular a filtragem como um “bloco” bem definido (um filtro como componente) é um padrão recorrente em arquitetura de sistemas embarcados, porque separa aquisição, filtragem e consumo do dado, facilitando testes e evolução do firmware.

O “mínimo que funciona” (pipeline recomendado)

Para a maioria dos sensores analógicos comuns (NTC, shunt com amplificador, potenciômetro, sensores de pressão), um pipeline simples funciona muito bem: você coleta N amostras rápidas, derruba outliers com mediana de 3 ou 5, e em seguida suaviza com um IIR 1-pole. A mediana protege contra picos (por exemplo, interferência curta de comutação), e o IIR dá suavidade com custo baixíssimo e latência controlável.

A seguir eu deixo códigos em C “portáveis”, onde você só precisa plugar sua função de leitura do ADC (no ATmega pode ser adc_read(), no ESP32 pode ser adc1_get_raw()/adc_oneshot_read()).

Filtro de média móvel (FIR simples) — bom para ruído “aleatório”, ruim para degrau rápido

A média móvel é o filtro mais lembrado porque é fácil de entender. Ela reduz ruído branco aproximadamente com ganho de suavização proporcional a √N, mas adiciona latência e “borra” degraus. Se seu sinal muda devagar (ex.: temperatura), ela é ótima.

#include <stdint.h>

typedef struct {
    uint32_t acc;
    uint16_t *buf;
    uint16_t size;
    uint16_t idx;
    uint8_t  primed;
} movavg_t;

void movavg_init(movavg_t *f, uint16_t *buffer, uint16_t size) {
    f->acc = 0;
    f->buf = buffer;
    f->size = size;
    f->idx = 0;
    f->primed = 0;
    for (uint16_t i = 0; i < size; i++) f->buf[i] = 0;
}

uint16_t movavg_update(movavg_t *f, uint16_t x) {
    f->acc -= f->buf[f->idx];
    f->buf[f->idx] = x;
    f->acc += x;

    f->idx++;
    if (f->idx >= f->size) {
        f->idx = 0;
        f->primed = 1;
    }

    // Durante o aquecimento, a média fica "puxada" para zero.
    // Você pode tratar isso retornando x até primed=1, se preferir.
    uint16_t denom = f->primed ? f->size : (f->idx == 0 ? 1 : f->idx);
    return (uint16_t)(f->acc / denom);
}

#include <stdint.h>

typedef struct {
    uint32_t acc;
    uint16_t *buf;
    uint16_t size;
    uint16_t idx;
    uint8_t  primed;
} movavg_t;

void movavg_init(movavg_t *f, uint16_t *buffer, uint16_t size) {
    f->acc = 0;
    f->buf = buffer;
    f->size = size;
    f->idx = 0;
    f->primed = 0;
    for (uint16_t i = 0; i < size; i++) f->buf[i] = 0;
}

uint16_t movavg_update(movavg_t *f, uint16_t x) {
    f->acc -= f->buf[f->idx];
    f->buf[f->idx] = x;
    f->acc += x;

    f->idx++;
    if (f->idx >= f->size) {
        f->idx = 0;
        f->primed = 1;
    }

    // Durante o aquecimento, a média fica "puxada" para zero.
    // Você pode tratar isso retornando x até primed=1, se preferir.
    uint16_t denom = f->primed ? f->size : (f->idx == 0 ? 1 : f->idx);
    return (uint16_t)(f->acc / denom);
}

No ATmega, isso é leve, mas se você usar janelas grandes (ex.: 64, 128) em uma taxa alta, vira custo de RAM e latência. No ESP32, geralmente é tranquilo.

Filtro IIR de 1ª ordem (passa-baixas “exponencial”) — o cavalo de batalha do firmware

Esse filtro é o “suavizador” mais usado em embarcados porque tem custo O(1), pouca RAM e é estável se você escolher o ganho corretamente. Ele implementa, na prática, uma média ponderada: o valor novo puxa o estado aos poucos. Em tempo discreto: y[n] = y[n-1] + α (x[n] - y[n-1]). O parâmetro α controla o compromisso entre suavidade e resposta.

Versão fixed-point (boa para ATmega, sem float)

Aqui eu uso Q15 (15 bits fracionários). alpha_q15 vai de 1 a 32767, equivalente a (0, 1).

#include <stdint.h>

typedef struct {
    int32_t y_q15;       // estado em Q15
    uint16_t alpha_q15;  // 0..32767 (~0..1)
    uint8_t initialized;
} iir1_q15_t;

void iir1_q15_init(iir1_q15_t *f, uint16_t alpha_q15) {
    if (alpha_q15 > 32767) alpha_q15 = 32767;
    f->y_q15 = 0;
    f->alpha_q15 = alpha_q15;
    f->initialized = 0;
}

uint16_t iir1_q15_update(iir1_q15_t *f, uint16_t x) {
    int32_t x_q15 = ((int32_t)x) << 15;

    if (!f->initialized) {
        f->y_q15 = x_q15;
        f->initialized = 1;
        return x;
    }

    // y = y + alpha*(x - y)
    int32_t err = x_q15 - f->y_q15;
    f->y_q15 += ( (int32_t)f->alpha_q15 * err ) >> 15;

    // arredondamento simples e saturação para 16 bits
    int32_t y = (f->y_q15 + (1 << 14)) >> 15;
    if (y < 0) y = 0;
    if (y > 65535) y = 65535;
    return (uint16_t)y;
}

#include <stdint.h>

typedef struct {
    int32_t y_q15;       // estado em Q15
    uint16_t alpha_q15;  // 0..32767 (~0..1)
    uint8_t initialized;
} iir1_q15_t;

void iir1_q15_init(iir1_q15_t *f, uint16_t alpha_q15) {
    if (alpha_q15 > 32767) alpha_q15 = 32767;
    f->y_q15 = 0;
    f->alpha_q15 = alpha_q15;
    f->initialized = 0;
}

uint16_t iir1_q15_update(iir1_q15_t *f, uint16_t x) {
    int32_t x_q15 = ((int32_t)x) << 15;

    if (!f->initialized) {
        f->y_q15 = x_q15;
        f->initialized = 1;
        return x;
    }

    // y = y + alpha*(x - y)
    int32_t err = x_q15 - f->y_q15;
    f->y_q15 += ( (int32_t)f->alpha_q15 * err ) >> 15;

    // arredondamento simples e saturação para 16 bits
    int32_t y = (f->y_q15 + (1 << 14)) >> 15;
    if (y < 0) y = 0;
    if (y > 65535) y = 65535;
    return (uint16_t)y;
}

Como escolher α sem virar matemática demais? Se você amostra a cada Ts e quer uma suavização equivalente a uma constante de tempo aproximada τ, uma aproximação prática é α ≈ Ts / (τ + Ts). Exemplo: amostragem a 1 kHz (Ts=1 ms) e você quer “assentar” em ~100 ms ⇒ α ≈ 0,001/(0,101) ≈ 0,0099, então alpha_q15 ≈ 0,0099 * 32768 ≈ 324. Isso dá um filtro bem suave.

Filtro de mediana — mata spikes sem “atrasar” tanto quanto média

Se o seu problema são picos curtos (ex.: ruído de chaveamento de relé, PWM, comutação de fonte), a mediana é muito eficiente. Para janela 3, o custo é mínimo.

#include <stdint.h>

static inline uint16_t median3_u16(uint16_t a, uint16_t b, uint16_t c) {
    // ordena parcialmente sem usar array
    if (a > b) { uint16_t t=a; a=b; b=t; }
    if (b > c) { uint16_t t=b; b=c; c=t; }
    if (a > b) { uint16_t t=a; a=b; b=t; }
    return b; // b é a mediana
}

typedef struct {
    uint16_t x1, x2;
    uint8_t primed;
} median3_t;

void median3_init(median3_t *f) {
    f->x1 = f->x2 = 0;
    f->primed = 0;
}

uint16_t median3_update(median3_t *f, uint16_t x) {
    if (!f->primed) {
        f->x2 = f->x1;
        f->x1 = x;
        if (f->x2 != 0) f->primed = 1;
        return x;
    }
    uint16_t y = median3_u16(f->x2, f->x1, x);
    f->x2 = f->x1;
    f->x1 = x;
    return y;
}

#include <stdint.h>

static inline uint16_t median3_u16(uint16_t a, uint16_t b, uint16_t c) {
    // ordena parcialmente sem usar array
    if (a > b) { uint16_t t=a; a=b; b=t; }
    if (b > c) { uint16_t t=b; b=c; c=t; }
    if (a > b) { uint16_t t=a; a=b; b=t; }
    return b; // b é a mediana
}

typedef struct {
    uint16_t x1, x2;
    uint8_t primed;
} median3_t;

void median3_init(median3_t *f) {
    f->x1 = f->x2 = 0;
    f->primed = 0;
}

uint16_t median3_update(median3_t *f, uint16_t x) {
    if (!f->primed) {
        f->x2 = f->x1;
        f->x1 = x;
        if (f->x2 != 0) f->primed = 1;
        return x;
    }
    uint16_t y = median3_u16(f->x2, f->x1, x);
    f->x2 = f->x1;
    f->x1 = x;
    return y;
}

Exemplo completo: mediana + IIR (bom “default” para ATmega e ESP32)

Aqui fica o esqueleto de uma função de “leitura filtrada” que você pode usar em uma task/loop periódico. Você substitui adc_read_raw() por sua leitura real.

#include <stdint.h>

// ---- mocks / stubs: substitua pela sua HAL ----
uint16_t adc_read_raw(void); // ATmega: ADC; ESP32: adc oneshot raw
// ----------------------------------------------

typedef struct {
    median3_t   med;
    iir1_q15_t  lp;
} adc_filter_t;

void adc_filter_init(adc_filter_t *f, uint16_t alpha_q15) {
    median3_init(&f->med);
    iir1_q15_init(&f->lp, alpha_q15);
}

uint16_t adc_read_filtered(adc_filter_t *f) {
    uint16_t x = adc_read_raw();
    uint16_t x_med = median3_update(&f->med, x);
    uint16_t y = iir1_q15_update(&f->lp, x_med);
    return y;
}

#include <stdint.h>

// ---- mocks / stubs: substitua pela sua HAL ----
uint16_t adc_read_raw(void); // ATmega: ADC; ESP32: adc oneshot raw
// ----------------------------------------------

typedef struct {
    median3_t   med;
    iir1_q15_t  lp;
} adc_filter_t;

void adc_filter_init(adc_filter_t *f, uint16_t alpha_q15) {
    median3_init(&f->med);
    iir1_q15_init(&f->lp, alpha_q15);
}

uint16_t adc_read_filtered(adc_filter_t *f) {
    uint16_t x = adc_read_raw();
    uint16_t x_med = median3_update(&f->med, x);
    uint16_t y = iir1_q15_update(&f->lp, x_med);
    return y;
}

No ATmega, isso costuma caber confortavelmente e resolve 80% dos casos reais. No ESP32, você pode manter igual ou trocar o IIR para float se quiser ajustar α dinamicamente com mais facilidade, mas não é necessário.

Quando isso não basta (e o que fazer)

Se o seu ruído é “bem comportado” (aleatório, de alta frequência), média móvel e IIR resolvem. Se o ruído é dominado por rede elétrica (50/60 Hz) acoplando no sensor, muitas vezes vale mais a pena atacar na causa (impedância de fonte, RC analógico antes do ADC, referência e aterramento) e depois, no firmware, usar um filtro que tenha rejeição nessa frequência, como um notch discreto ou uma média sincronizada com o período (quando você sabe a fase). E se o ADC está sofrendo com fonte de alta impedância, nenhum filtro compensa totalmente: aí você melhora o circuito (buffer com op-amp, capacitor no sample/hold, tempo de aquisição maior, etc.) antes de “pedir milagre” ao DSP.

The post Filtragem de ruído em leituras ADC em microcontroladores (ATmega e ESP32) com exemplos em C first appeared on MCU & FPGA.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    size_t store = left;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    size_t store = left;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <string.h> // memcpy

#define N  15

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

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

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

    return median_adc_u16_inplace(tmp, N);
}

#include <string.h> // memcpy

#define N  15

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

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

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

    return median_adc_u16_inplace(tmp, N);
}

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

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

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

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

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

A parte “enganosa” das IMUs é que ler registradores e imprimir “Ax, Ay, Az” quase nunca resolve o problema real. O valor está cru, com bias (offset), ruído, drift, saturação, escalas diferentes, e no caso do magnetômetro ainda existe distorção de hard-iron/soft-iron. O objetivo aqui é te mostrar um caminho de uso que funciona na prática: inicialização correta, aquisição consistente, calibração e, por fim, fusão de sensores para produzir orientação e métricas refinadas.

1) Arquitetura do MPU9250 e o que isso muda no firmware

O MPU9250 tem dois “mundos” que você precisa coordenar:

1. Accel/Gyro (bloco principal) acessado direto pelo barramento do host (I²C ou SPI).
2. Magnetômetro (AK8963) acessado de duas formas: ou você coloca o MPU em “pass-through / bypass” e fala direto com o AK8963 no endereço I²C 0x0C, ou você usa o barramento auxiliar interno do MPU (modo “master”) para o MPU ler o magnetômetro e disponibilizar os dados ao host. A própria especificação descreve o uso do pass-through e cita explicitamente o endereço do AK8963. (TDK InvenSense)

Para simplificar e reduzir “magia” no início, muitos projetos usam pass-through: o host configura e lê o magnetômetro como se fosse outro dispositivo I²C no mesmo barramento. Isso também facilita depuração com ferramentas como i2cdetect, embora existam armadilhas de configuração.

2) O “pipeline” certo: do dado cru ao dado refinado

Um pipeline robusto costuma seguir esta lógica (mesmo que você implemente em etapas):

1. Leitura atômica de accel/gyro (idealmente usando burst read para garantir coerência temporal).
2. Conversão de escala (LSB → unidades físicas).
3. Compensação de bias (offset) e, se necessário, escala fina (ganho).
4. Filtragem leve (LPF) para reduzir ruído sem destruir dinâmica.
5. Fusão de sensores para estimar orientação:
   • Complementary filter (simples e bom) para roll/pitch
   • Madgwick/Mahony (quaternions) para roll/pitch/yaw com magnetômetro
6. Calibração do magnetômetro (hard-iron/soft-iron) para yaw confiável.

A ideia é: se você pular a calibração e fusão, yaw vai “dançar”, gyro vai derivar e vibração vira um festival de falso-positivo.

3) Base de firmware em C: leitura, escala e filtros

Abaixo vai um esqueleto que separa responsabilidades: driver (registradores) e processamento (algoritmos). Eu vou deixar as funções i2c_read e i2c_write como “portáveis” (você adapta para STM32 HAL, ESP-IDF, baremetal etc.).

3.1 Tipos e constantes úteis

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

/* Endereços I2C típicos do MPU9250: 0x68 (AD0=0) ou 0x69 (AD0=1). */
#define MPU9250_ADDR 0x68

/* Magnetômetro AK8963 no pass-through/bypass: 0x0C */
#define AK8963_ADDR  0x0C  /* citado na especificação do MPU9250 :contentReference[oaicite:2]{index=2} */

/* Exemplo de faixas (você escolhe conforme aplicação) */
typedef enum {
  ACC_FS_2G = 0,
  ACC_FS_4G,
  ACC_FS_8G,
  ACC_FS_16G
} acc_fs_t;

typedef enum {
  GYR_FS_250DPS = 0,
  GYR_FS_500DPS,
  GYR_FS_1000DPS,
  GYR_FS_2000DPS
} gyr_fs_t;

typedef struct {
  float ax, ay, az;   /* m/s^2 */
  float gx, gy, gz;   /* rad/s */
  float mx, my, mz;   /* uT (ou unidade relativa, depende do seu fator) */
  float temp_c;
  uint32_t t_us;      /* timestamp (opcional) */
} imu_sample_t;

typedef struct {
  /* Bias estimado (offset) */
  float acc_bias[3];
  float gyr_bias[3];
  float mag_bias[3];

  /* Matriz 3x3 de correção do magnetômetro (soft-iron) */
  float mag_softiron[3][3];

  /* Fatores de escala em unidades físicas por LSB */
  float acc_lsb_to_mps2;
  float gyr_lsb_to_rads;
  float mag_lsb_to_uT; /* depende do modo do AK8963 e do datasheet dele */
} imu_cal_t;

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

/* Endereços I2C típicos do MPU9250: 0x68 (AD0=0) ou 0x69 (AD0=1). */
#define MPU9250_ADDR 0x68

/* Magnetômetro AK8963 no pass-through/bypass: 0x0C */
#define AK8963_ADDR  0x0C  /* citado na especificação do MPU9250 :contentReference[oaicite:2]{index=2} */

/* Exemplo de faixas (você escolhe conforme aplicação) */
typedef enum {
  ACC_FS_2G = 0,
  ACC_FS_4G,
  ACC_FS_8G,
  ACC_FS_16G
} acc_fs_t;

typedef enum {
  GYR_FS_250DPS = 0,
  GYR_FS_500DPS,
  GYR_FS_1000DPS,
  GYR_FS_2000DPS
} gyr_fs_t;

typedef struct {
  float ax, ay, az;   /* m/s^2 */
  float gx, gy, gz;   /* rad/s */
  float mx, my, mz;   /* uT (ou unidade relativa, depende do seu fator) */
  float temp_c;
  uint32_t t_us;      /* timestamp (opcional) */
} imu_sample_t;

typedef struct {
  /* Bias estimado (offset) */
  float acc_bias[3];
  float gyr_bias[3];
  float mag_bias[3];

  /* Matriz 3x3 de correção do magnetômetro (soft-iron) */
  float mag_softiron[3][3];

  /* Fatores de escala em unidades físicas por LSB */
  float acc_lsb_to_mps2;
  float gyr_lsb_to_rads;
  float mag_lsb_to_uT; /* depende do modo do AK8963 e do datasheet dele */
} imu_cal_t;

3.2 Funções “portáveis” de barramento

/**
 * @brief Lê N bytes de um registrador.
 * @return true se sucesso.
 */
bool i2c_read(uint8_t dev, uint8_t reg, uint8_t *buf, uint16_t len);

/**
 * @brief Escreve 1 byte em um registrador.
 */
bool i2c_write(uint8_t dev, uint8_t reg, uint8_t value);

/**
 * @brief Lê N bytes de um registrador.
 * @return true se sucesso.
 */
bool i2c_read(uint8_t dev, uint8_t reg, uint8_t *buf, uint16_t len);

/**
 * @brief Escreve 1 byte em um registrador.
 */
bool i2c_write(uint8_t dev, uint8_t reg, uint8_t value);

4) Inicialização prática: o mínimo que evita dor de cabeça

Aqui entram três pontos: clock, ranges e habilitar leitura coerente. Para o magnetômetro via pass-through, você também precisa habilitar o bypass no MPU e configurar o AK8963. O documento de especificação descreve o “pass-through mode” justamente para permitir que o host acesse o AK8963 diretamente. (TDK InvenSense)

Observação importante: os endereços de registradores (PWR_MGMT_1, INT_PIN_CFG etc.) ficam no register map do MPU9250. Se você já usa uma lib, ótimo; se não, use o RM oficial para confirmar endereços e bits. (TDK InvenSense)

Exemplo (conceitual, com registradores “nomeados” via defines que você tiraria do RM):

/* Estes defines você deve mapear pelo Register Map oficial. :contentReference[oaicite:5]{index=5} */
#define REG_PWR_MGMT_1     0x6B
#define REG_PWR_MGMT_2     0x6C
#define REG_CONFIG         0x1A
#define REG_GYRO_CONFIG    0x1B
#define REG_ACCEL_CONFIG   0x1C
#define REG_ACCEL_CONFIG2  0x1D
#define REG_INT_PIN_CFG    0x37
#define REG_USER_CTRL      0x6A

/* Bits típicos: consultar RM */
#define BIT_BYPASS_EN      0x02  /* INT_PIN_CFG */
#define BIT_I2C_MST_EN     0x20  /* USER_CTRL (se usar master interno) */

static bool mpu9250_init_basic(acc_fs_t acc_fs, gyr_fs_t gyr_fs)
{
  /* 1) Acorda o chip e seleciona clock (ex.: PLL) */
  if (!i2c_write(MPU9250_ADDR, REG_PWR_MGMT_1, 0x01)) return false;

  /* 2) Configura filtros digitais (DLPF) conforme seu fs e ruído */
  if (!i2c_write(MPU9250_ADDR, REG_CONFIG, 0x03)) return false;

  /* 3) Faixa do giroscópio */
  uint8_t gcfg = (uint8_t)(gyr_fs << 3);
  if (!i2c_write(MPU9250_ADDR, REG_GYRO_CONFIG, gcfg)) return false;

  /* 4) Faixa do acelerômetro */
  uint8_t acfg = (uint8_t)(acc_fs << 3);
  if (!i2c_write(MPU9250_ADDR, REG_ACCEL_CONFIG, acfg)) return false;

  /* 5) Config do accel DLPF */
  if (!i2c_write(MPU9250_ADDR, REG_ACCEL_CONFIG2, 0x03)) return false;

  return true;
}

/* Habilita pass-through para acessar AK8963 direto no I2C (0x0C). :contentReference[oaicite:6]{index=6} */
static bool mpu9250_enable_mag_passthrough(void)
{
  /* Desabilita master interno (se estiver ligado) e ativa bypass */
  if (!i2c_write(MPU9250_ADDR, REG_USER_CTRL, 0x00)) return false;
  if (!i2c_write(MPU9250_ADDR, REG_INT_PIN_CFG, BIT_BYPASS_EN)) return false;
  return true;
}

/* Estes defines você deve mapear pelo Register Map oficial. :contentReference[oaicite:5]{index=5} */
#define REG_PWR_MGMT_1     0x6B
#define REG_PWR_MGMT_2     0x6C
#define REG_CONFIG         0x1A
#define REG_GYRO_CONFIG    0x1B
#define REG_ACCEL_CONFIG   0x1C
#define REG_ACCEL_CONFIG2  0x1D
#define REG_INT_PIN_CFG    0x37
#define REG_USER_CTRL      0x6A

/* Bits típicos: consultar RM */
#define BIT_BYPASS_EN      0x02  /* INT_PIN_CFG */
#define BIT_I2C_MST_EN     0x20  /* USER_CTRL (se usar master interno) */

static bool mpu9250_init_basic(acc_fs_t acc_fs, gyr_fs_t gyr_fs)
{
  /* 1) Acorda o chip e seleciona clock (ex.: PLL) */
  if (!i2c_write(MPU9250_ADDR, REG_PWR_MGMT_1, 0x01)) return false;

  /* 2) Configura filtros digitais (DLPF) conforme seu fs e ruído */
  if (!i2c_write(MPU9250_ADDR, REG_CONFIG, 0x03)) return false;

  /* 3) Faixa do giroscópio */
  uint8_t gcfg = (uint8_t)(gyr_fs << 3);
  if (!i2c_write(MPU9250_ADDR, REG_GYRO_CONFIG, gcfg)) return false;

  /* 4) Faixa do acelerômetro */
  uint8_t acfg = (uint8_t)(acc_fs << 3);
  if (!i2c_write(MPU9250_ADDR, REG_ACCEL_CONFIG, acfg)) return false;

  /* 5) Config do accel DLPF */
  if (!i2c_write(MPU9250_ADDR, REG_ACCEL_CONFIG2, 0x03)) return false;

  return true;
}

/* Habilita pass-through para acessar AK8963 direto no I2C (0x0C). :contentReference[oaicite:6]{index=6} */
static bool mpu9250_enable_mag_passthrough(void)
{
  /* Desabilita master interno (se estiver ligado) e ativa bypass */
  if (!i2c_write(MPU9250_ADDR, REG_USER_CTRL, 0x00)) return false;
  if (!i2c_write(MPU9250_ADDR, REG_INT_PIN_CFG, BIT_BYPASS_EN)) return false;
  return true;
}

5) Aquisição coerente: burst read e conversão para unidades físicas

A leitura ideal é em “bloco”, porque isso reduz a chance de pegar metade do sample antigo e metade do novo (especialmente quando você lê eixos separados).

#define REG_ACCEL_XOUT_H 0x3B  /* base do bloco accel/temp/gyro no RM */

/* Layout típico do burst: accel(6), temp(2), gyro(6) => 14 bytes */
static bool mpu9250_read_accel_gyro_raw(int16_t acc[3], int16_t gyr[3], int16_t *temp)
{
  uint8_t buf[14];
  if (!i2c_read(MPU9250_ADDR, REG_ACCEL_XOUT_H, buf, 14)) return false;

  acc[0] = (int16_t)((buf[0] << 8) | buf[1]);
  acc[1] = (int16_t)((buf[2] << 8) | buf[3]);
  acc[2] = (int16_t)((buf[4] << 8) | buf[5]);

  *temp = (int16_t)((buf[6] << 8) | buf[7]);

  gyr[0] = (int16_t)((buf[8]  << 8) | buf[9]);
  gyr[1] = (int16_t)((buf[10] << 8) | buf[11]);
  gyr[2] = (int16_t)((buf[12] << 8) | buf[13]);

  return true;
}

/* Converte valores crus para físico, já aplicando bias */
static void imu_convert_apply_cal(
  const int16_t acc_raw[3],
  const int16_t gyr_raw[3],
  const imu_cal_t *cal,
  float acc_mps2[3],
  float gyr_rads[3]
){
  /* LSB -> unidade e remove bias */
  for (int i = 0; i < 3; i++) {
    acc_mps2[i] = (float)acc_raw[i] * cal->acc_lsb_to_mps2 - cal->acc_bias[i];
    gyr_rads[i] = (float)gyr_raw[i] * cal->gyr_lsb_to_rads - cal->gyr_bias[i];
  }
}

#define REG_ACCEL_XOUT_H 0x3B  /* base do bloco accel/temp/gyro no RM */

/* Layout típico do burst: accel(6), temp(2), gyro(6) => 14 bytes */
static bool mpu9250_read_accel_gyro_raw(int16_t acc[3], int16_t gyr[3], int16_t *temp)
{
  uint8_t buf[14];
  if (!i2c_read(MPU9250_ADDR, REG_ACCEL_XOUT_H, buf, 14)) return false;

  acc[0] = (int16_t)((buf[0] << 8) | buf[1]);
  acc[1] = (int16_t)((buf[2] << 8) | buf[3]);
  acc[2] = (int16_t)((buf[4] << 8) | buf[5]);

  *temp = (int16_t)((buf[6] << 8) | buf[7]);

  gyr[0] = (int16_t)((buf[8]  << 8) | buf[9]);
  gyr[1] = (int16_t)((buf[10] << 8) | buf[11]);
  gyr[2] = (int16_t)((buf[12] << 8) | buf[13]);

  return true;
}

/* Converte valores crus para físico, já aplicando bias */
static void imu_convert_apply_cal(
  const int16_t acc_raw[3],
  const int16_t gyr_raw[3],
  const imu_cal_t *cal,
  float acc_mps2[3],
  float gyr_rads[3]
){
  /* LSB -> unidade e remove bias */
  for (int i = 0; i < 3; i++) {
    acc_mps2[i] = (float)acc_raw[i] * cal->acc_lsb_to_mps2 - cal->acc_bias[i];
    gyr_rads[i] = (float)gyr_raw[i] * cal->gyr_lsb_to_rads - cal->gyr_bias[i];
  }
}

6) Calibração essencial: bias do giroscópio e “leveling” do acelerômetro

6.1 Bias do giroscópio (parado)

O gyro sempre tem um offset. Se você integrar gyro “cru”, a orientação deriva mesmo com o sensor parado. O método mais robusto para começar é: durante 2–5 s com o dispositivo imóvel, calcule a média de Gx,Gy,Gz e chame isso de bias.

static void calibrate_gyro_bias(imu_cal_t *cal, int samples, float dt_s)
{
  (void)dt_s; /* aqui dt não é necessário, mas você pode checar estabilidade */
  double sum[3] = {0,0,0};

  for (int n = 0; n < samples; n++) {
    int16_t acc_raw[3], gyr_raw[3], temp_raw;
    if (!mpu9250_read_accel_gyro_raw(acc_raw, gyr_raw, &temp_raw)) continue;

    sum[0] += (double)gyr_raw[0];
    sum[1] += (double)gyr_raw[1];
    sum[2] += (double)gyr_raw[2];
  }

  cal->gyr_bias[0] = (float)(sum[0]/samples) * cal->gyr_lsb_to_rads;
  cal->gyr_bias[1] = (float)(sum[1]/samples) * cal->gyr_lsb_to_rads;
  cal->gyr_bias[2] = (float)(sum[2]/samples) * cal->gyr_lsb_to_rads;
}

static void calibrate_gyro_bias(imu_cal_t *cal, int samples, float dt_s)
{
  (void)dt_s; /* aqui dt não é necessário, mas você pode checar estabilidade */
  double sum[3] = {0,0,0};

  for (int n = 0; n < samples; n++) {
    int16_t acc_raw[3], gyr_raw[3], temp_raw;
    if (!mpu9250_read_accel_gyro_raw(acc_raw, gyr_raw, &temp_raw)) continue;

    sum[0] += (double)gyr_raw[0];
    sum[1] += (double)gyr_raw[1];
    sum[2] += (double)gyr_raw[2];
  }

  cal->gyr_bias[0] = (float)(sum[0]/samples) * cal->gyr_lsb_to_rads;
  cal->gyr_bias[1] = (float)(sum[1]/samples) * cal->gyr_lsb_to_rads;
  cal->gyr_bias[2] = (float)(sum[2]/samples) * cal->gyr_lsb_to_rads;
}

Para o acelerômetro, o bias depende muito de como você define “referência”: em repouso, ele mede gravidade projetada no frame do sensor. Um jeito prático: faça uma calibração simples em repouso com o sensor em uma orientação conhecida (por exemplo, Z apontando para cima), e ajuste apenas o eixo da gravidade. Para calibração “de verdade”, você faz a técnica de 6 faces (±X, ±Y, ±Z), mas isso já vira um procedimento de bancada.

7) Filtro passa-baixa simples (IIR) e por que ele é suficiente em muita coisa

Em IMU, um filtro IIR de 1ª ordem é o “feijão com arroz” porque custa quase nada e reduz ruído.

typedef struct {
  float y[3];
  float alpha; /* 0..1  (quanto menor, mais filtrado) */
} lpf1_t;

static void lpf1_init(lpf1_t *f, float alpha)
{
  f->alpha = alpha;
  f->y[0] = f->y[1] = f->y[2] = 0.0f;
}

static void lpf1_update(lpf1_t *f, const float x[3], float out[3])
{
  for (int i = 0; i < 3; i++) {
    f->y[i] = f->alpha * f->y[i] + (1.0f - f->alpha) * x[i];
    out[i] = f->y[i];
  }
}

typedef struct {
  float y[3];
  float alpha; /* 0..1  (quanto menor, mais filtrado) */
} lpf1_t;

static void lpf1_init(lpf1_t *f, float alpha)
{
  f->alpha = alpha;
  f->y[0] = f->y[1] = f->y[2] = 0.0f;
}

static void lpf1_update(lpf1_t *f, const float x[3], float out[3])
{
  for (int i = 0; i < 3; i++) {
    f->y[i] = f->alpha * f->y[i] + (1.0f - f->alpha) * x[i];
    out[i] = f->y[i];
  }
}

Escolha de alpha: se seu loop é 200 Hz, alpha entre 0,85 e 0,98 costuma funcionar bem para suavizar sem “matar” dinâmica. Para vibração e manutenção preditiva, você pode filtrar menos (alpha menor) e trabalhar com FFT/PSD em janelas curtas.

8) Orientação “refinada”: Complementary Filter (rápido e bom) e caminho para quaternions

8.1 Roll e Pitch com Complementary Filter

O acelerômetro dá uma boa referência de inclinação (porque a gravidade aponta “para baixo”), mas é ruidoso e sofre com acelerações lineares. O gyro é suave e rápido, mas deriva. O filtro complementar mistura os dois: gyro domina no curto prazo, accel corrige no longo prazo.

typedef struct {
  float roll;   /* rad */
  float pitch;  /* rad */
  float alpha;  /* ex.: 0.98 */
} comp_t;

static void comp_init(comp_t *c, float alpha)
{
  c->roll = 0.0f;
  c->pitch = 0.0f;
  c->alpha = alpha;
}

static void comp_update(comp_t *c, const float acc[3], const float gyr[3], float dt)
{
  /* roll_acc = atan2(Ay, Az) ; pitch_acc = atan2(-Ax, sqrt(Ay^2+Az^2)) */
  float roll_acc  = atan2f(acc[1], acc[2]);
  float pitch_acc = atan2f(-acc[0], sqrtf(acc[1]*acc[1] + acc[2]*acc[2]));

  /* Integra gyro (assumindo gyr[] em rad/s) */
  float roll_g  = c->roll  + gyr[0]*dt;
  float pitch_g = c->pitch + gyr[1]*dt;

  /* Mistura */
  c->roll  = c->alpha*roll_g  + (1.0f - c->alpha)*roll_acc;
  c->pitch = c->alpha*pitch_g + (1.0f - c->alpha)*pitch_acc;
}

typedef struct {
  float roll;   /* rad */
  float pitch;  /* rad */
  float alpha;  /* ex.: 0.98 */
} comp_t;

static void comp_init(comp_t *c, float alpha)
{
  c->roll = 0.0f;
  c->pitch = 0.0f;
  c->alpha = alpha;
}

static void comp_update(comp_t *c, const float acc[3], const float gyr[3], float dt)
{
  /* roll_acc = atan2(Ay, Az) ; pitch_acc = atan2(-Ax, sqrt(Ay^2+Az^2)) */
  float roll_acc  = atan2f(acc[1], acc[2]);
  float pitch_acc = atan2f(-acc[0], sqrtf(acc[1]*acc[1] + acc[2]*acc[2]));

  /* Integra gyro (assumindo gyr[] em rad/s) */
  float roll_g  = c->roll  + gyr[0]*dt;
  float pitch_g = c->pitch + gyr[1]*dt;

  /* Mistura */
  c->roll  = c->alpha*roll_g  + (1.0f - c->alpha)*roll_acc;
  c->pitch = c->alpha*pitch_g + (1.0f - c->alpha)*pitch_acc;
}

Isso já resolve uma quantidade enorme de aplicações: estabilização simples, detecção de inclinação, controle de plataforma, etc. Mas ainda falta yaw (rumo).

8.2 Yaw e magnetômetro: onde quase todo mundo sofre

Yaw com magnetômetro só fica bom se você fizer duas coisas:

1. Hard-iron: remover offset (a “nuvem” de pontos do mag não fica centrada no zero).
2. Soft-iron: corrigir escala/rotação (a nuvem vira uma elipse em vez de esfera).

O procedimento prático é coletar dados do magnetômetro girando o dispositivo em várias orientações, ajustar uma elipse e transformar para esfera. Em firmware embarcado simples, você pode aplicar uma aproximação: bias = (max+min)/2 por eixo e escala = (max-min)/2 para normalizar. Não é perfeito, mas melhora muito.

Aplicação de correção (bias + matriz soft-iron):

static void mag_apply_cal(const imu_cal_t *cal, const float m_raw[3], float m_corr[3])
{
  float v[3] = {
    m_raw[0] - cal->mag_bias[0],
    m_raw[1] - cal->mag_bias[1],
    m_raw[2] - cal->mag_bias[2]
  };

  /* m_corr = SoftIron * v */
  for (int r = 0; r < 3; r++) {
    m_corr[r] =
      cal->mag_softiron[r][0]*v[0] +
      cal->mag_softiron[r][1]*v[1] +
      cal->mag_softiron[r][2]*v[2];
  }
}

static void mag_apply_cal(const imu_cal_t *cal, const float m_raw[3], float m_corr[3])
{
  float v[3] = {
    m_raw[0] - cal->mag_bias[0],
    m_raw[1] - cal->mag_bias[1],
    m_raw[2] - cal->mag_bias[2]
  };

  /* m_corr = SoftIron * v */
  for (int r = 0; r < 3; r++) {
    m_corr[r] =
      cal->mag_softiron[r][0]*v[0] +
      cal->mag_softiron[r][1]*v[1] +
      cal->mag_softiron[r][2]*v[2];
  }
}

Depois disso, para obter yaw “tilt-compensated” (compensado por roll/pitch), você projeta o vetor magnético no plano horizontal do mundo (ou do corpo) usando a orientação atual. Se você já estiver em quaternions (Madgwick/Mahony), isso fica limpo. Se você estiver em roll/pitch, dá para fazer com trigonometria também, mas o ideal para robustez é migrar para quaternion.

9) Leitura do magnetômetro (pass-through) e sincronismo

Quando você usa pass-through, o host lê o AK8963 em 0x0C diretamente, o que é exatamente o que o modo foi feito para permitir. (TDK InvenSense) A atenção aqui é garantir que você está lendo no ritmo correto e respeitando o “data ready” do magnetômetro (senão você repete amostras).

Um pseudo-exemplo (registradores do AK8963 você pega do datasheet/register map do AK):

/* Endereços do AK8963 (exemplo comum) */
#define AK8963_ST1   0x02
#define AK8963_HXL   0x03
#define AK8963_CNTL1 0x0A

static bool ak8963_init_16bit_100hz(void)
{
  /* Exemplo: modo contínuo 100Hz e saída 16-bit (depende do CNTL1) */
  return i2c_write(AK8963_ADDR, AK8963_CNTL1, 0x16);
}

static bool ak8963_read_raw(int16_t mag[3])
{
  uint8_t st1;
  if (!i2c_read(AK8963_ADDR, AK8963_ST1, &st1, 1)) return false;

  if (!(st1 & 0x01)) {
    /* dado ainda não pronto */
    return false;
  }

  uint8_t buf[7];
  if (!i2c_read(AK8963_ADDR, AK8963_HXL, buf, 7)) return false;

  /* Atenção: AK8963 costuma ser little-endian */
  mag[0] = (int16_t)((buf[1] << 8) | buf[0]);
  mag[1] = (int16_t)((buf[3] << 8) | buf[2]);
  mag[2] = (int16_t)((buf[5] << 8) | buf[4]);

  return true;
}

/* Endereços do AK8963 (exemplo comum) */
#define AK8963_ST1   0x02
#define AK8963_HXL   0x03
#define AK8963_CNTL1 0x0A

static bool ak8963_init_16bit_100hz(void)
{
  /* Exemplo: modo contínuo 100Hz e saída 16-bit (depende do CNTL1) */
  return i2c_write(AK8963_ADDR, AK8963_CNTL1, 0x16);
}

static bool ak8963_read_raw(int16_t mag[3])
{
  uint8_t st1;
  if (!i2c_read(AK8963_ADDR, AK8963_ST1, &st1, 1)) return false;

  if (!(st1 & 0x01)) {
    /* dado ainda não pronto */
    return false;
  }

  uint8_t buf[7];
  if (!i2c_read(AK8963_ADDR, AK8963_HXL, buf, 7)) return false;

  /* Atenção: AK8963 costuma ser little-endian */
  mag[0] = (int16_t)((buf[1] << 8) | buf[0]);
  mag[1] = (int16_t)((buf[3] << 8) | buf[2]);
  mag[2] = (int16_t)((buf[5] << 8) | buf[4]);

  return true;
}

10) Nota de engenharia: NRND/EOL e o que fazer com isso

A TDK/InvenSense marca o MPU-9250 como fim de vida / não recomendado para novos projetos, então em produto final vale considerar sucessores (ex.: ICM-20948 e outros, dependendo do que você precisa). (TDK InvenSense) Para aprendizado, laboratório, hobby e protótipos, ele continua sendo excelente justamente porque existe muito material, exemplos e bibliotecas.

Exemplos de gráficos em Python (no final, como referência)

Abaixo está um script didático que gera dados sintéticos (simulados) de aceleração, giroscópio, magnetômetro e também a orientação (Euler) usada como referência do exemplo. Ele serve para você enxergar a “cara” típica dos eixos e como eles variam no tempo. É útil para validar pipeline, filtros e escalas antes de plugar no hardware.

The post MPU9250: como usar uma IMU 9 eixos e extrair dados realmente “úteis” first appeared on MCU & FPGA.

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

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

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

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

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

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

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

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

1.1 O papel do Goertzel nesta nova arquitetura

É importante deixar claro desde o início:

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

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

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

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

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

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

Vamos trabalhar com modelos:

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

Exemplos que abordaremos ao longo do artigo:

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

Tudo isso é:

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

1.3 Por que limiares fixos falham em campo

Nos artigos anteriores, usamos decisões do tipo:

• score > S_ON
• score < S_OFF

Isso funciona bem quando:

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

Mas em campo real:

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

Resultado:
limiar bom hoje, ruim amanhã.

O aprendizado estatístico resolve exatamente isso:

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

1.4 Visão geral da nova arquitetura

A nova cadeia de processamento será:

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

Comparando com o artigo anterior:

1.5 O que você terá ao final deste artigo

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

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

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

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

1 — LPC (Linear Predictive Coding)

O que significa LPC

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

Em termos simples:

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

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

Intuição física e de sinal

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

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

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

Isso é importante porque:

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

Modelo matemático do LPC

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

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

onde:

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

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

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

Por que o LPC é importante para LPCC

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

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

Ou seja:

LPC modela o sistema
LPCC descreve o sistema

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

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

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

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

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

#include <stddef.h>

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

#include <stddef.h>

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

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

Observações práticas para sistemas embarcados

Do ponto de vista de firmware e IoT: