Demod not working with Deinterleave

Hi.

I have modified benchmark_rx.py/receive_path.py to allow it to receive
two channels from two RFX2400 daughterboards (I aim to use the second
channel for sensing).

As suggested by the examples/mailing list, I inserted a deinterleave
block after the source to retrieve streams from each channel, like so
[my two receive channels are RFX2400 “A” side, TX/RX plug as channel 0,
RFX2400 “B” side, TX/RX plug as channel 1.)

self.u = usrp.source_c(which = 0, decim_rate = self._decim, nchan = 2,
mux = gru.hexint(0x10321032), fusb_block_size = self._fusb_block_size,
fusb_nblocks = self._fusb_nblocks, fpga_filename=“std_2rxhb_2tx.rbf”)
self.di = gr.deinterleave(gr.sizeof_gr_complex)


(rx_receive_path = essentially receive_path without the source at the
front)

self.rx_receive_path = rx_receive_path(self._demod_class,
self._rx_callback, options)

self.connect(self.u, self.di)
self.connect( (self.di, self._rx_chan), self.rx_receive_path)

I can get this to run.

However when my transmitter usrp runs, my new receiver picks up junk
packets. The receiver demodulates the packets so that all the data is
messed up (ok = False, data nonsense). I have confirmed the transmitter
and receiver have matched bitrates and I am certain my mux setting is
correct. I suspect there is a problem with dbpsk demodulation of the
source stream.

My rx_receive_path is (i.e. receive_path):

    # Get demod_kwargs
    demod_kwargs = demod_class.extract_kwargs_from_options(options)

    # Design filter to get actual channel we want
    sw_decim = 1 #sw_decim stands for "software decimation"
    chan_coeffs = gr.firdes.low_pass (1.0,                  # gain
                                      sw_decim *

options.samples_per_symbol, # sampling rate
1.0, #
midpoint of trans. band
0.5, # width
of trans. band
gr.firdes.WIN_HANN) # filter
type

‘’’
vector< float > gr.firdes::low_pass ( double gain,
double sampling_freq,
double cutoff_freq,
double transition_width,
win_type window = WIN_HAMMING,
double beta = 6.76)
[static]
‘’’

    # Decimating channel filter
    # complex in and out, float taps
    self.chan_filt = gr.fft_filter_ccc(sw_decim, chan_coeffs)

    # receiver
    self.packet_receiver = \
        blks2.demod_pkts(demod_class(**demod_kwargs),
                         access_code=None,
                         callback=rx_callback, #no doubt this object

calls rx_callback’s function whenever a packet arrives, and sets the
packet
threshold=-1) #blks2 is calling a
function in gnuradio/gnuradio-core/src/python/ gnuradio/blksimpl/pkt.py

    self.connect(self, self.chan_filt, self.packet_receiver) #io

signature

This is identical to receive_path.py.

Why would this receiver code not work when I introduce
deinterleaving/two channels? (receiver demodulates to give junk data)

Also I will want to have my two RX channels operate at different
decimation rates. I will want to introduce extra software decimation in
rx_receive_path. This is achieved by modifying chan_filt.

Can someone explain the chan_coeffs in chan_filt. Specifically how have
the chan_coeffs arguments (sampling rate, cutoff frequency, etc.) been
derived for receive_path?

Will it be sufficient for instance if my usrp decim is 16 and I want a
rx decim of 32, to specify e.g.: (sw_decim = 32/16 = 2 -> extra software
decimation factor)

    # Design filter to get actual channel we want
    sw_decim = 2 #sw_decim stands for "software decimation"
    chan_coeffs = gr.firdes.low_pass (1.0,                  # gain
                                      2 *

options.samples_per_symbol, # sampling rate
1.0, #
midpoint of trans. band
0.5, # width
of trans. band
gr.firdes.WIN_HANN) # filter
type

‘’’
vector< float > gr.firdes::low_pass ( double gain,
double sampling_freq,
double cutoff_freq,
double transition_width,
win_type window = WIN_HAMMING,
double beta = 6.76)
[static]
‘’’

    # Decimating channel filter
    # complex in and out, float taps
    self.chan_filt = gr.fft_filter_ccc(2, chan_coeffs)

Bump

Please don’t spam the GNU Radio mailing list with trash like this.

John G.

Hi

Have you solved your problem? because I’m facing the same problem.
I think in your code there are two mistakes:

  1. the mux value should be set to 00230001 not 10321032.
  2. may be you are missing :
    self._rx_subdev = self._u.db(0) + self._u.db(1)

Anyway, I’m not sure. but because when i do :
usrp.determine_rx_mux_value(self._u,(0,0))- i get —> 1 ----->0x01
usrp.determine_rx_mux_value(self._u,(1,0))- i get —> 35 ---->0x23

thanks

Smart RoR wrote:

[my two receive channels are RFX2400 “A” side, TX/RX plug as channel 0,

However when my transmitter usrp runs, my new receiver picks up junk

type

packet

rx_receive_path. This is achieved by modifying chan_filt.
sw_decim = 2 #sw_decim stands for “software decimation”
‘’’
# complex in and out, float taps


View this message in context:
http://old.nabble.com/Demod-not-working-with-Deinterleave-tp23518611p28199629.html
Sent from the GnuRadio mailing list archive at Nabble.com.