A fin d'éliminer le bruit ou limiter la réponse à des phénomènes perturbateurs, les acquisitions venant de l'ADC peuvent être traitées par un FPB (Filtre Passe-Bas), qui peut être implémenté sous la forme d'un filtre exponentiel de premier ordre (un pôle) :

Value := Value + K*(New - Value);

Où K est de la forme 1/N.

Si N est choisi comme un multiple de 2, l'implémentation effective pour des entiers est grandement simplifiée :

Value := (Value * (N - 1) + New) div N;

Ce qui peut ensuite être fortement optimisé par le compilateur en utilisant un décalage à droite final.

Quelles différences avec une moyenne glissante classique de la forme :

Value := (Sample_0 + Sample_1 + ... + Sample_n) div n ?

Tout d'abord, si N=2, le filtre est strictement équivalent à une moyenne classique avec la valeur courante et non sur les acquisitions uniquement :

Value := Value + (New - Value) div 2 == Value := (Value + New) div 2 ;

Ensuite vous n'avez pas à accumuler les valeurs dans un tableau ou une variable de taille supérieure.
Ensuite la réponse est très différente (exponentielle et non linéaire) et le filtre à un pôle fournit une valeur en sortie dès que la première valeur en entrée est traitée.
Finalement un meilleur traitement peut être obtenu en utilisant plusieurs pôles en cascade, avec des valeurs N plus faibles. La réponse est alors encore améliorée.

Inconvénient courant d'une implémentation purement entière : la précision des valeurs faibles est réduite et la valeur du résultat peut plafonner à une valeur dans l'intervalle Value-N .. Value + N.

Pour contourner ce problème, on peut utiliser un accumulateur mis à l'échelle, disons : un accumulateur de 32 bits pour des valeurs d'entrée de 16 bits.

Exemple:

Nous pouvons utiliser des valeurs multipliées par P₃₂ = 65536; c'est optimal car 65536 = (1 shl 16).

La formule devient alors :

AccValue₃₂ := (AccValue₃₂ * (N - 1) + NewValue₃₂ * P₃₂) div N;

Value₁₆ := AccValue₃₂ div P₃₂;

Avec N = 16, P₃₂ = 65536 et une nouvelle valeur en entrée sur 16 bits New₁₆, il vient :

AccValue₃₂ := (AccValue₃₂ * 15 + (longword(New₁₆) shl 16) shr 4;

Value₁₆ := hiword(AccValue₃₂); // La valeur filtrée en sortie sur 16 bits est simplement le mot supérieur de l'accumulateur.

A l'initialisation (ou à la première valeur), on fait :

AccValue₃₂ := longword(New₁₆) shl 16;

Value₁₆ := New₁₆;

Il est aisé pour le compilateur d'optimiser la formule avec des décalages et il n'y a plus de phénomènes de plancher ou de plafonnement.