To minimize noise or to limit the response to a disturbing phenomenon, the ADC values may be processed by a LPF (Low Pass Filter) that may be easily implemented with a very common exponential single pole filter:

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

Where K is of the form 1/N.

if N is chosen as a multiple of 2, the effective implementation with simple integers will be simplified a lot:

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

Which should be optimized by the compiler by using a final right shift.

What are the differences with a classic averaging like Value := (Sample_0 + Sample_1 + ... + Sample_n) div n?

First, if N=2 the filter is strictly equivalent to a classic average:

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

Then you don't have to accumulate the values in an array or in a larger variable.
Then the response is very different (exponential instead of linear) and the exponential single pole filter will output a value as soon as the first sample is crunched.
Finally a better response may be achieved by cascading several poles with a smaller N value.

Common drawback of a pure integer implementation: The small values accuracy is lowered and Value may suffer from ceiling in the Value-N .. Value + N range.

To workaround this, we may use a scaled accumulator, say: a 32-bit accumulator for filtering 16-bit values.

Example:

We may use values scaled by P₃₂ = 65536; this is optimal because 65536 = (1 shl 16).

The formula becomes:

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

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

With N = 16, and P₃₂ = 65536 and 16-bit New₁₆ input value, it comes:

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

Value₁₆ := hiword(AccValue₃₂); // The filtered 16-bit output value is simply the high word of the accumulator.

At initialization (or at first input value), we do:

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

Value₁₆ := New₁₆;

This is easy for the compiler's optimizer to generate fast code and there is no floor or ceiling phenomenon.