Média móvel com buffer circular

Uma sequência de leituras pode ser escrita como x[k], em que k indica a posição da amostra na sequência. A saída da média móvel será y[k].

Exemplo: se x[0] = 10, x[1] = 14 e x[2] = 12, esses são três valores de entrada em instantes consecutivos. Para uma janela de tamanho N, y[k] é a média das N amostras mais recentes, incluindo sempre a amostra atual x[k].

Neste step, considere somente janelas já completas.

Com a janela cheia, a regra é:

y[k] = (x[k] + x[k − 1] + ... + x[k − N + 1]) / N

Se N = 4, cada saída usa exatamente quatro amostras consecutivas. Ao chegar uma nova amostra, a janela avança uma posição: o novo valor entra e o valor que ficou mais distante no passado deixa de participar. Não se somam todas as leituras recebidas desde o início.

Ainda com N = 4, use a sequência:

x[0]=8, x[1]=10, x[2]=14, x[3]=12, x[4]=16, x[5]=18

Complete a média da janela que termina em k=5:

y[5] = (14 + 12 + 16 + {{blank}}) / 4

Para uma janela cheia de N amostras:

• y[k] usa x[k] e as N − 1 amostras imediatamente anteriores.
• A amostra atual faz parte da média.
• Na saída seguinte, entra uma nova amostra e sai a mais antiga da janela anterior.
• A notação x representa a entrada; y representa a saída filtrada.

Nos próximos steps, essa mesma janela será mantida na memória sem deslocar todos os valores do vetor.

Um vetor que dá a volta

Depois que a janela está cheia, não é preciso deslocar todas as amostras no vetor para abrir espaço. Um buffer circular reutiliza posições de um vetor fixo.

Considere N = 4 e uma janela, em ordem temporal, com as amostras 10, 20, 30, 40. Quando a próxima amostra, 50, chegar, a mais antiga (10) deve sair da janela. O índice de escrita aponta exatamente para a posição que contém essa amostra antiga.

Assim, basta sobrescrever uma posição e avançar o índice. Ao alcançar o fim do vetor, o índice retorna a 0.

Duas ordens diferentes

A ordem física é a numeração fixa das posições do vetor: 0, 1, 2, 3. Já a ordem temporal indica quando cada valor foi recebido: do mais antigo ao mais novo.

Essas ordens coincidem apenas em alguns instantes. Depois que o índice retorna ao início, elas deixam de coincidir. Por exemplo, após substituir 10 por 50, o vetor físico fica {50, 20, 30, 40}. Mas a janela temporal passa a ser 20, 30, 40, 50.

Não interprete o vetor da posição 0 até N - 1 como uma sequência cronológica sem considerar o índice.

Escrita e avanço do índice; considere que buffer já contém N amostras válidas.

Coloque os estados na ordem em que ocorrem. O buffer tem N = 4, está cheio com {10, 20, 30, 40} e indice = 3. A nova amostra é 50.

Com a janela já cheia, mantenha soma como um estado: ela é a soma exata dos valores presentes no buffer naquele instante. A média continua sendo calculada por soma / N, sem somar todas as posições novamente a cada amostra.

Quando chega uma entrada, apenas um valor sai da janela e apenas um entra. Portanto, a soma anterior pode ser corrigida em vez de recalculada.

Trecho para uma janela já cheia.

Considere uma janela cheia com N = 4, buffer = {7, 11, 9, 13}, indice = 2 e soma = 40. Chega novo = 15.

Faça a troca mentalmente: a posição 2 contém 9, que sai; 15 entra nessa posição. Qual alternativa mostra tanto a nova soma incremental quanto a conferência pela soma direta do buffer resultante?

Complete os termos que mantêm o acumulador coerente ao trocar a amostra apontada por indice. Considere que a janela já está cheia.

A atualização incremental usa uma quantidade fixa de ações por amostra: acessar uma posição, subtrair, gravar, adicionar e avançar o índice. Esse trabalho não cresce quando N aumenta, pois não há laço percorrendo a janela a cada atualização.

Em contrapartida, o buffer precisa de N posições reservadas previamente. Assim, a memória é proporcional a N, enquanto o trabalho de atualização permanece independente do tamanho da janela.

Antes da primeira amostra, inicialize o estado assim: vetor com zeros, indice = 0, soma = 0 e validas = 0.

Os zeros no vetor são apenas valores seguros para a memória ainda vazia — não são medições. Portanto, eles não podem entrar no divisor da média.

Quando chega uma amostra válida, ela entra no buffer e validas cresce. Enquanto a janela não está cheia, a saída é:

y = soma / validas

Quando validas chega a N, ela para de crescer. A partir daí, cada nova amostra substitui a mais antiga e a divisão continua usando validas, que já vale N.

A atualização abaixo preserva a lógica do buffer circular já estudada. A condição sobre validas impede que a contagem ultrapasse N. A divisão ocorre depois que a nova amostra foi contabilizada; assim, a função só calcula uma média quando há ao menos uma amostra válida e nunca divide por zero.

Trecho para estudar e incorporar ao estado persistente do filtro.

A amostra do ADC do Uno pode caber em uint16_t: ela vai de 0 a 1023. Mas a variável soma guarda várias amostras ao mesmo tempo e precisa de outra verificação.

Para entradas não negativas, calcule o pior caso:

S_max = N × x_max

Aqui, N é a capacidade da janela e x_max é o maior valor possível de uma amostra. Escolha um acumulador que comporte S_max com margem compatível com seu projeto.

Uma média móvel recebe códigos entre 0 e 1023 e usa N = 80. Qual alternativa calcula corretamente a soma máxima e escolhe um acumulador adequado?

Faça o cálculo do limite em um tipo amplo desde o começo. Não basta declarar a variável de destino como uint32_t: se a multiplicação ocorrer antes em um tipo estreito, o resultado já pode ter transbordado.

Na média, a mesma atenção vale para a divisão. Quando os dois operandos são inteiros, a fração é descartada antes de qualquer conversão posterior.

Cálculo seguro do limite e média com parte fracionária preservada.

A função abaixo reúne o que você já construiu: memória fixa, índice circular, soma incremental e contagem válida. O estado fica fora da função para persistir entre chamadas. Com N = 4, cada chamada troca no máximo uma posição do vetor e faz a divisão pela quantidade de amostras válidas.

A sequência importa: retire o valor antigo da soma, grave a nova amostra, acrescente-a à soma, atualize a contagem e avance o índice. Assim, o valor removido ainda está disponível quando é necessário.

Trecho 1 — coloque no início de um sketch Arduino.

Acrescente este trecho logo depois do trecho anterior, no mesmo sketch. Ele usa dados sintéticos: não exige sensor, circuito ou biblioteca externa.

Ts_ms = 10 declara que as amostras representam espaçamento nominal de 10 ms. As linhas no monitor serial podem aparecer com outro intervalo, pois a transmissão serial não define o período de amostragem.

Trecho 2 — acrescente após o trecho 1 e envie o sketch ao seu Uno, se quiser executar localmente.

Use estes pontos de conferência para rastrear o sketch mesmo sem Arduino. A primeira linha confirma que posições zeradas não entram como medições: a divisão é por count = 1. A linha k=4 é a primeira substituição. Em k=7 e k=11, o índice retornou ao início após completar outra volta.

Com amostras regulares, a janela de uma média móvel de tamanho N tem duração nominal:

N × T_s

Ela reúne N medições, incluindo a atual. Já o intervalo entre a amostra mais antiga e a atual é menor:

(N − 1) × T_s

Exemplo: com N = 4 e T_s = 10 ms, a janela é chamada de 40 ms, mas seus extremos estão separados por 30 ms. As duas medidas são úteis, mas não são a mesma coisa.

Quando a janela está cheia e as amostras são regulares, uma referência prática para variações lentas é o atraso característico:

atraso ≈ (N − 1) × T_s / 2

Para N = 4 e T_s = 10 ms, o resultado é 15 ms. Para N = 8, é 35 ms.

Isso não significa que a saída fica imóvel durante esse tempo. Ao chegar uma nova amostra, ela já entra na média e a saída começa a mudar. O valor é uma forma de localizar aproximadamente a resposta média da janela no tempo.

Se uma nova amostra de 140 chega após esse patamar, as duas médias mudam já nessa primeira atualização. A de N = 4 muda mais porque 1/4 da sua janela foi renovada; a de N = 8 também muda, mas a nova amostra representa só 1/8 da janela. A transição completa continua nas atualizações seguintes, enquanto as amostras antigas são substituídas.

Use exatamente a mesma sequência para duas execuções separadas: primeiro com N = 4, depois com N = 8. O espaçamento nominal das amostras é T_s = 10 ms.

Os 12 primeiros valores representam um patamar próximo de 500 com pequenas perturbações. Os 8 valores seguintes representam uma mudança para o patamar 700. Compare as saídas somente depois que cada janela estiver cheia.

Para que o segundo resultado não carregue amostras do primeiro, reinicialize completamente o estado antes de cada ensaio: buffer, índice, soma e contagem válida.

O sketch a seguir é completo e independente: crie um novo sketch para ele, em vez de acrescentá-lo ao sketch do step anterior. A função executarEnsaio() define a janela ativa, chama reiniciar() e processa todos os dados. Assim, os ensaios com N = 4 e N = 8 usam a mesma entrada, mas estados separados.

O buffer tem capacidade máxima de 8 posições; N seleciona quantas posições participam do ensaio atual. A soma permanece em uint32_t, e a conversão para float ocorre antes da divisão.

Sketch completo para executar localmente no Arduino Uno; não requer sensor, circuito nem biblioteca externa.

A tabela confronta a entrada com as duas saídas calculadas pela sequência do ensaio. Entre k = 8 e k = 11, ambas as janelas já estão cheias e o patamar ainda está perturbado. Em k = 12, entra a primeira amostra de 700: as duas saídas sobem imediatamente, mas em quantidades diferentes.