Filtro digital recursivo de primeira ordem

Um filtro recursivo calcula a nova saída usando a entrada atual e a saída que havia sido calculada antes. Por isso, ele mantém um estado entre atualizações.

Nesta etapa, considere a saída anterior y[k − 1] como esse estado guardado. Quando chega x[k], o filtro a compara com o estado e produz a nova saída y[k]. Em seguida, y[k] fica disponível como estado para a próxima atualização.

A atualização do filtro é:

y[k] = y[k − 1] + α × (x[k] − y[k − 1])

Leia-a em três partes:

1. Comece pelo estado anterior: y[k − 1].
2. Calcule a diferença até a entrada atual: x[k] − y[k − 1].
3. Some apenas uma parte dessa diferença: α × (x[k] − y[k − 1]).

Essa parcela é a correção. Assim, a nova saída não é calculada do zero: ela ajusta o valor que o filtro já mantinha.

Associe cada elemento ao seu papel em uma atualização do filtro.

Em cada atualização, o filtro segue esta ideia:

estado anterior → diferença até a entrada → correção parcial → novo estado

A recursão está no reaproveitamento da saída anterior. Na próxima tela, você rastreará esse estado ao longo de várias amostras e verá como diferentes valores de α alteram a resposta.

O coeficiente α define quanto da diferença entre a entrada atual e o estado anterior será corrigido em cada atualização:

y[k] = y[k − 1] + α × (x[k] − y[k − 1])

Neste tutorial, adotamos 0 < α ≤ 1. Nessa faixa, diante de uma mudança de patamar, a saída avança em direção à entrada sem alternar para os dois lados do novo valor.

• α = 1: a correção é toda a diferença; então y[k] = x[k]. Não há suavização.
• α menor: apenas uma parte da diferença é corrigida a cada amostra. A saída fica mais suave, mas reage mais devagar.

Na primeira atualização:

x[1] = 10

y[1] = 0 + 0,5 × (10 − 0) = 5

Na atualização seguinte, o estado anterior não é mais zero: é y[1] = 5.

x[2] = 10

y[2] = 5 + 0,5 × (10 − 5) = 7,5

Mesmo com a entrada mantida em 10, a correção diminui: primeiro foi 5; depois, 2,5. A saída se aproxima do patamar sem alcançá-lo de uma só vez.

Use α = 0,5, estado inicial y[0] = 4 e entrada x[1] = 10.

Complete a saída após essa atualização:

y[1] = 4 + 0,5 × (10 − 4) = {{lacuna}}

A mesma sequência recebe duas configurações, ambas com y[0] = 0. A entrada muda de 0 para 10 e permanece em 10.

Observe que α = 0,8 chega mais perto da entrada logo na primeira atualização do que α = 0,2. Isso significa resposta mais rápida, mas também menor suavização das variações de amostra para amostra.

Quando a entrada fica em um patamar constante, a saída se aproxima dela. A cada atualização, a diferença que ainda falta é multiplicada por 1 − α.

Se faltavam 10 unidades e α = 0,2, depois da atualização faltam 8: o filtro corrigiu 20% da diferença. Na próxima, corrigirá 20% do que restou. Portanto, α define o decaimento por amostra — mas, para definir a rapidez no tempo, também precisamos de T_s.

Para associar o filtro a uma constante de tempo desejada, use:

α = 1 − exp(−T_s / τ_f)

• T_s: período entre atualizações;
• τ_f: constante de tempo desejada para o filtro;
• ambos devem ser positivos e estar na mesma unidade.

exp(z) é a função exponencial da calculadora ou da linguagem de programação. Não é preciso calcular derivadas.

Quanto menor for T_s em relação a τ_f, menor será α: cada atualização fará uma correção pequena, mas haverá mais atualizações no mesmo intervalo de tempo.

A razão T_s/τ_f não tem unidade. Por isso, milissegundos e segundos funcionam igualmente bem, desde que sejam usados de modo consistente.

Se o período mudar, o mesmo α mantém o mesmo comportamento por atualização, mas não necessariamente por segundo.

Um filtro configurado com T_s = 20 ms e τ_f = 100 ms usa α ≈ 0,1813. Se T_s passar para 40 ms e α for mantido, as correções ocorrerão com metade da frequência. O filtro ficará mais lento no tempo.

Para preservar τ_f = 100 ms, recalcule: α = 1 − exp(−40/100) ≈ 0,3297.

Calcule a exponencial na configuração inicial ou quando T_s ou τ_f mudar. Nas atualizações normais, use apenas o α já calculado; não é necessário chamar exp() a cada amostra.

A função do filtro recebe uma amostra válida e devolve a saída filtrada. Para funcionar entre chamadas, ela precisa guardar dois dados fora da função: o último valor filtrado (estado) e se já existe uma primeira amostra (inicializado).

Na primeira chamada, ainda não há saída anterior para aplicar à equação. Portanto, copie a medição para o estado e retorne-a. Nas chamadas seguintes, atualize o mesmo estado com o coeficiente alpha já calculado.

Declare o estado uma vez, em um escopo que continue existindo enquanto o programa roda. O indicador booleano separa o caso inicial das atualizações normais.

A função abaixo pressupõe que alpha está entre 0 e 1 e que amostra já foi considerada válida por quem a chama.

Código para estudar e usar em seu projeto local.

Uma atualização do filtro tem uma correção: α × (entrada − estado). Se essa correção for fracionária, mas o resultado for guardado em uma variável inteira, a parte decimal é descartada.

Exemplo: com estado 100, entrada 101 e α = 0,2, a correção é 0,2. O novo valor matemático seria 100,2; em um int, ele volta a ser 100. Na próxima atualização, a mesma correção pode desaparecer de novo. Assim, o filtro fica parado apesar de ainda existir diferença até a entrada.

O problema não é a fórmula do filtro, e sim o local onde seu resultado é armazenado. Mantenha em ponto flutuante:

• alpha;
• o estado persistente;
• a diferença e a correção intermediárias.

Converta para inteiro apenas na interface que realmente exigir isso, por exemplo ao enviar um valor para um hardware ou uma API que aceite somente inteiros. O estado interno não deve ser convertido a cada amostra.

Compare as duas versões. A primeira perde a parte fracionária toda vez que atribui o resultado ao estado inteiro.

A relação entre α, período de atualização e constante de tempo pressupõe duas condições: cada entrada usada é válida e as atualizações ocorrem regularmente. Se uma leitura falha ou chega depois de uma lacuna, ela não representa simplesmente “mais uma amostra” na mesma sequência temporal.

Uma política simples separa o valor armazenado do status dele. Em uma falha curta, não execute a atualização recursiva: preserve y anterior e informe que a saída está desatualizada. Assim, quem usa a saída sabe que ela não representa uma medição recente.

Defina um limiar de interrupção longa, adequado à aplicação: por exemplo, uma quantidade de períodos perdidos ou um tempo sem amostra válida. Ao ultrapassá-lo, marque o filtro como “precisa reinicializar”. Na próxima amostra válida, use-a para inicializar o estado, em vez de aplicar a equação sobre um estado antigo.

Para comparar de forma justa, aplique aos dois filtros o mesmo período de atualização T_s e a mesma sequência de entrada. Antes de uma mudança de patamar, deixe ambos estabelecidos no valor inicial: assim, a diferença observada vem do filtro, e não de condições iniciais diferentes.

Observe dois aspectos separadamente:

• Flutuação residual: quanto as saídas ainda variam diante de pequenas perturbações.
• Resposta à mudança: quantas atualizações cada saída leva para se aproximar do novo patamar.

O filtro recursivo usa a saída anterior e α. A média móvel usa a janela das últimas N amostras. Nenhum é universalmente “melhor”: a escolha depende da prioridade do sistema.

Neste exemplo, ambos os filtros já estavam em 100 antes da tabela. A média móvel tem N = 4 e o recursivo usa α = 0,25. Os valores estão arredondados.

As pequenas perturbações alternadas mostram a flutuação residual. A partir de k = 5, a entrada passa a 120: compare o atraso de cada saída sem chamar nenhuma delas de atraso puro.

Neste caso integrado, o filtro recebe uma amostra a cada T_s = 100 ms e deve ter τ_f = 500 ms. A sequência sintética é: 20, 20, 30, duas amostras inválidas, 30 e 20.

Use a política definida: uma amostra inválida mantém a última saída, identificada como desatualizada. Após duas posições consecutivas inválidas, o estado é reinicializado; a próxima amostra válida passa a ser a nova saída inicial.

O coeficiente é calculado uma vez na configuração:

α = 1 − exp(−T_s / τ_f)

Com T_s = 0,1 s e τ_f = 0,5 s, α ≈ 0,181269. Assim, uma mudança de 20 para 30 é corrigida parcialmente: a saída vai para aproximadamente 21,812692, não diretamente para 30.

Copie este programa inteiro para um único sketch, se quiser executá-lo na sua IDE ou em um Arduino Uno próprio. Ele não exige sensor nem circuito externo: as amostras são sintéticas.