I am working on a GR block that will test two incoming bit streams (one
a
reference and one a received result) for equality and return the
estimated
BER. Blocks already exist that do this, but they assume the streams are
aligned. My block will allow and correct for offsets in the bit
streams.
The goal is to use this with existing physical comm systems - i.e.
Generate
and transmit a PRBS with GR and USRP to a legacy comm system, capture
the
RX’s data and clock, bring them back into the flowgraph and compare the
reference data to the received data to get estimated BER.
My block does work for streams that are aligned, but I am having
difficulty
dealing with misalignment. Somehow, the blocks needs to have more of
the
reference signal (if not all of it) to compare against the smaller
segments
of received data every time the work function is called.
I see several possible approaches and the purpose of this email is to
solicit advice from those with more experience than I.
-
Use set_history() and history() to good effect.
I’ve tried this, but haven’t gotten the desired results. This may be
misunderstanding of the feature on my part, but I think the fundamental
problem is comparing two streams of equal length when one is offset from
the other. -
Accumulate a specified window of reference signal before comparing to
received signal.
This approach would accumulate the reference signal in a buffer that
would
be used for comparison. Until the work function calls accumulated some
threshold of reference data in the buffer, the received signal would be
passed without comparison or BER calculation. Once the threshold is
met,
the small chunks of received data would be compared against the much
larger
(and growing, but limited to repeat length) reference buffer.
I have not implemented this approach yet, but I suspect it will work as
long as the window is picked reasonably - the safest bet being the
length
of the PRBS used in the test.
The disadvantage of this method is that the PRBS may be very long, but
the
sample rate may be slow and therefore there would be a long waiting
period
as the reference buffer fills before the test even truly begins.
- Variation on previous approach.
To alleviate the setup time of filling the reference buffer, perhaps we
could generate the whole PRBS in the block constructor. The block would
then have a “menu” of standard PRBS’s commonly used int BER testing.
We’d
probably want to make a companion PRBS source block with the same menu
for
the transmitting segment.
If anyone has any thoughts on this, I’d appreciate the input. This is
one
of those problems that’s pretty simple in a standalone python program,
but
gets a little more complicated when implemented in GR. But there’s a
lot
of benefit in the implementation too.
To anticipate a few questions: For my testing, I have been using no
hardware, just a GLFSR source with skiphead to implement offset (delay
block adds zeros, which get interpreted as bit errors). I use a
separate
sequence to modify the stream with a known number of errors for testing.
As I said, the block works perfectly with no offset.
Alignment is implemented by shifting the reference sequence relative to
the
received sequence, calculating the residual between the two at each step
and using the minimum value of that residual as the current error count.
This should be the point where the sequences are most ideally aligned,
which works as long as the error rate is relatively low. The reason
alignment doesn’t work in my current implementation is because the
reference and received sequences are the same length, so if there is any
offset, even when aligned, it looks like there are n errors where n is
the
offset between the sequences. So, the reference sequence needs to be
longer than the reference sequence, and ideally approaching the length
of
the PRBS itself to correct for any offset.
Thanks for suffering through to the end.
Very Respectfully,
Dan CaJacob