On Thu, 3 Jul 2003 15:02:08 +0200, "\(-=-ToToF-=-\)"
<papilufr@yahoo.fr> wrote:

>Hi everybody,
>
>Someone explains to me that to estimate the SNR of the channel (and then the
>BER of a modem), i have to use the output bits of the viterbi decoder. These
>bits are convolutionnally encoded and the output is compared with the signal
>received.
>
>Someone can tell me about the precision of this method ?
>I've tried to search informations with google but i didn't find anything.

That's one way, but it's not the only way.

I'll expound a little and you tell me whether this makes sense to you
or not:

In AWGN (an assumption I'm making unless you say different, although
the discussion may change if this is not the case), there is a 1:1 map
from the SNR performance to BER for a reasonably engineered
demodulator.   In other words, at some point you can put the thing on
a bench with a calibrated noise test set and measure BER vs SNR and
plot the resulting curve.   Given some small margin for manufacturing
tolerance this curve should be pretty repeatable from unit to unit.  

Do this with the Viterbi decoder turned off and you have the BER vs
SNR curve that can be used for a simple method of SNR estimation.  If
the modulator and demodulator are well-designed this curve of
raw-error-rate vs SNR should be the matched filter bound plus whatever
the implementation loss of the mod and demod happen to be.  A good mod
and demod in AWGN can run as close as a few of tenths of a dB from the
theoretical matched filter bound.  Cheap units for consumer products
will be worse, YMMV.

The idea, then, is that at the output of the Viterbi the recovered
data stream can be re-encoded with the appropriate convolutional
encoder and compared to a delayed version of the original raw input
stream that the Viterbi decoder just decoded.  In other words, you're
using the correction capability of the Viterbi to locate corrected
errors.   Count the corrected errors over some time interval and this
will provide a good estimate of the RAW BER which then allows you to
look up the SNR from the curve you generated previously.

That's one way to estimate SNR, and it's pretty simple to implement if
you're using a Viterbi decoder.  It's also pretty accurate if
manufacturing tolerances are reasonably well controlled.

Another way is to use the recovered constellation and decision slicer
and generate an estimate of the error vector and its magnitude.  The
error vector magnitude is a good estimate of the noise level for that
symbol, so accumulating a bunch of these over time allows a pretty
easy estimate of the noise power to be made relative to the signal
level.  It should be pretty easy to see how to get an SNR estimate
from there.

This does, however require more arithmetical operations to be
performed than the re-encode-and-compare method I described earlier.
It's good for systems that don't lend themselves well to
re-encode-and-compare techniques, though, e.g.,  the encoder is
complex like with an LDPC, Turbo Code, or even a Reed-Solomon.

Hope that helps a bit or two.

Cheers,

Eric Jacobsen
Minister of Algorithms, Intel Corp.
My opinions may not be Intel's opinions.
http://www.ericjacobsen.org