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$oles 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, disns : une 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, P32 = 65536 et une nouvelle valeur en entrée sur 16 bits New16, 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 wot supérieur de l'accumulateur.

A l'initialisation (ou à la prepiè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.