Started by November 23, 2010
```Dear all,

I have just been reading about the use of oversampling in a decimator to
enhance the resolution of a sampled signal.

The idea is to sample a signal containing 0.5LSB white noise at samplerate
of N times the Nyquist rate. It is then possible to extract log4(N) extra
bits of resolution by summing N samples.

However there is another scheme which can provide much more of an increase
in resolution.

noise. The result is that ADC sample dithering will take place on almost

eg. with noise of LSB, averaged over 6 samples
x=([0:360]/360)*2*pi; y=sin(x); v=[y' y' y' y' y' y']; b=4; n=(1/b)*1;
z=round(v*(b/2)+rand(length(y),columns(v)).*n)/(b/2); plot(mean(z'));

eg. with noise of 5*LSB averages over 6 samples
x=([0:360]/360)*2*pi; y=sin(x); v=[y' y' y' y' y' y']; b=4; n=(1/b)*5;
z=round(v*(b/2)+rand(length(y),columns(v)).*n)/(b/2); plot(mean(z'));

The second curve is much smoother and accurate.

Why is this method not mentioned in most texts about oversampling? It seems
that it is possible to get much more bits out of signal without increasing
the samplerate to extremely high frequencies.

Thanks for the remarks!

```
```On 11/23/2010 04:04 PM, dwjbosman wrote:
> Dear all,
>
> I have just been reading about the use of oversampling in a decimator to
> enhance the resolution of a sampled signal.
>
> The idea is to sample a signal containing 0.5LSB white noise at samplerate
> of N times the Nyquist rate. It is then possible to extract log4(N) extra
> bits of resolution by summing N samples.
>
> However there is another scheme which can provide much more of an increase
> in resolution.
>
> noise. The result is that ADC sample dithering will take place on almost
>
> eg. with noise of LSB, averaged over 6 samples
> x=([0:360]/360)*2*pi; y=sin(x); v=[y' y' y' y' y' y']; b=4; n=(1/b)*1;
> z=round(v*(b/2)+rand(length(y),columns(v)).*n)/(b/2); plot(mean(z'));
>
> eg. with noise of 5*LSB averages over 6 samples
> x=([0:360]/360)*2*pi; y=sin(x); v=[y' y' y' y' y' y']; b=4; n=(1/b)*5;
> z=round(v*(b/2)+rand(length(y),columns(v)).*n)/(b/2); plot(mean(z'));
>
> The second curve is much smoother and accurate.
>
> Why is this method not mentioned in most texts about oversampling? It seems
> that it is possible to get much more bits out of signal without increasing
> the samplerate to extremely high frequencies.
>
> Thanks for the remarks!

I don't know the full answer, but I _do_ know that as you increase the
noise level you'll need more averaging to get it back out again, but
you'll get better linearity.

Note 1: you won't necessarily increase the _accuracy_ of the ADC -- that
may be lost to various ADC errors (nonlinearity, scaling, etc.).  But
you'll certainly improve the _precision_ of the ADC.

Note 2: Matlab exercises do not constitute proof.  They merely suggest.
Learn how to do this analysis on paper, and you'll see the issues much
easier.

--

Tim Wescott
Wescott Design Services
http://www.wescottdesign.com

Do you need to implement control loops in software?
"Applied Control Theory for Embedded Systems" was written for you.
See details at http://www.wescottdesign.com/actfes/actfes.html
```
```On Nov 23, 8:22&#2013266080;pm, Tim Wescott <t...@seemywebsite.com> wrote:
> On 11/23/2010 04:04 PM, dwjbosman wrote:
>
>
>
> > I have just been reading about the use of oversampling in a decimator to
> > enhance the resolution of a sampled signal.
>
> > The idea is to sample a signal containing 0.5LSB white noise at samplerate
> > of N times the Nyquist rate. It is then possible to extract log4(N) extra
> > bits of resolution by summing N samples.
>
> > However there is another scheme which can provide much more of an increase
> > in resolution.
>
> > noise. The result is that ADC sample dithering will take place on almost
>
> > eg. with noise of LSB, averaged over 6 samples
> > x=([0:360]/360)*2*pi; y=sin(x); v=[y' y' y' y' y' y']; b=4; n=(1/b)*1;
> > z=round(v*(b/2)+rand(length(y),columns(v)).*n)/(b/2); plot(mean(z'));
>
> > eg. with noise of 5*LSB averages over 6 samples
> > x=([0:360]/360)*2*pi; y=sin(x); v=[y' y' y' y' y' y']; b=4; n=(1/b)*5;
> > z=round(v*(b/2)+rand(length(y),columns(v)).*n)/(b/2); plot(mean(z'));
>
> > The second curve is much smoother and accurate.
>
> > Why is this method not mentioned in most texts about oversampling? It seems
> > that it is possible to get much more bits out of signal without increasing
> > the samplerate to extremely high frequencies.
>
> > Thanks for the remarks!
>
> I don't know the full answer, but I _do_ know that as you increase the
> noise level you'll need more averaging to get it back out again, but
> you'll get better linearity.
>
> Note 1: you won't necessarily increase the _accuracy_ of the ADC -- that
> may be lost to various ADC errors (nonlinearity, scaling, etc.). &#2013266080;But
> you'll certainly improve the _precision_ of the ADC.
>
> Note 2: Matlab exercises do not constitute proof. &#2013266080;They merely suggest.
> &#2013266080; Learn how to do this analysis on paper, and you'll see the issues much
> easier.

this is what i know about it, and i don't know everything.  getting a
dissertation from Robert Wannamaker might tell you everything about
it.

what i know is that, if your A/D acts as a linear quantizer (and we
know they ain't perfectly linear), if you add 1 LSB rectangular p.d.f.
dither, the mean value of the quantization error is decoupled from the
input signal getting quantized, and if you add 2 LSB triangular p.d.f.
dither, both the mean and variance of the error signal is decoupled
from the input.  we expect that once the variance (which is,
essentially, the quantization noise power) is decoupled, all of the
perceptual qualities of the quantization error is unaffected: it just
sounds like white noise.  adding 2 LSB triangular dither adds 4.77 dB
to the energy of quantization noise (that delta^2/12 thing).  to
completely decouple the first two moments of the quantization noise
signal is accomplished with the least additive dither power if the
dither is triangular p.d.f. and 2 LSBs in size.  gaussian can do it,
but with a bigger dither signal.

now, for fixing the non-linearities of the A/D staircase function (the
somewhat unequal step sizes), that would require an even bigger dither
signal and it may not be particularly helpful to use any special
p.d.f. so you may as well have gaussian (which is what you'll get in
the analog domain).

another thing to note (assuming you are decoupling the quantization
error with sufficient noise) is that you gain 3.01 dB S/N every time
you double the sampling rate.  this means, to turn a good 16-bit
converter to an equally honest 17-bit converter, you would need to
oversample by a factor of 4.  but this oversampling thing doesn't work
unless you are tickling your input signal with sufficient dither noise
(which loses you at least 4.77 dB to start with, but you gain 6 dB
every time you quadruple the sampling rate).