2 RX and 1 TX channel

GNU Radio
1

Hello every one,

I am using USRP1 + RFX2400.

I want to use 2 RFX2400 cards. Overall I will have 2 RX streams and 1 TX
stream from this system. Following are main parts of my RX_Path
(complete
code for RX-Path is also attached, if you want please have a look on
that,
TX-path is not here). I am unable to receive anything from any of the
channels although the same RX-path was working when I was using a sinle
antenna. Only following lines were mainly changed. Please have a look
and
let me know if my configuration for 2 RX (on separate RFX cards, but one
USRP1 main board) and one TX channel.

u = usrp.source_c(0, decim_rate=self.usrp_decim, nchan=2
self.subdev = (self.u.db[0][0] , self.u.db[1][0])
self.u.set_mux(gru.hexint(0x3210))

#Set the gain to the midway point
self.subdev[0].set_gain(60)
self.subdev[1].set_gain(60)

#Set the recieve frequency
self.r0 = usrp.tune(self.u, 0, self.subdev[0], 2.41e9)
self.r1 = usrp.tune(self.u, 1, self.subdev[1], 2.41e9)

self.subdev[0].select_rx_antenna( ‘RX2’)
self.subdev[1].select_rx_antenna( ‘RX2’)

self.deinter = gr.deinterleave(gr.sizeof_gr_complex)

#enable Auto Transmit/Receive switching
self.set_auto_tr(True)

self.connect(self.u,self.deinter)
self.connect ((self.deinter,0), self.rx_filter, self.fmdemod, self.corr,
self.vec_sink) # One RX antenna for regular data reception
self.connect ((self.deinter,1), self.fft_input) #Other RX antenna for
fft
window, this fft will be further processed

http://www.nabble.com/file/p24305532/receive_path.py receive_path.py

Best Regards

View this message in context:
http://www.nabble.com/2-RX-and-1-TX-channel-tp24305532p24305532.html
Sent from the GnuRadio mailing list archive at Nabble.com.

2

In addition to my above mentioned question, please also comment on what
should be the value of mux (I am setting 0x3210) and what should be the
value of fpga_filename,

Please again note that I want to use 2 RFX2400 cards with one USRP1, and
2
rx streams will be there each through RX2 antenna of 2 RFX2400 cards and
there will be one tx stream through any one of these cards.

Best Regards

Kaleem Ahmad

kaleem ahmad wrote:

antenna. Only following lines were mainly changed. Please have a look and
self.subdev[1].set_gain(60)
#enable Auto Transmit/Receive switching

Best Regards

–
View this message in context:
http://www.nabble.com/2-RX-and-1-TX-channel-tp24305532p24306722.html
Sent from the GnuRadio mailing list archive at Nabble.com.

3

Hallo everyone,

I dont get any reply so far, may be I can rephrase my question.

Actually I was expecting that any code which is working fine for a
single
antenna, will only need little changes (Mentioned above in 1st post on
this
thread) to convert it to multiple antenna. I mean I was expectring that
I
would only need to direct streams of two different antennas to
folwgraphs of
my already working code. BUT its not working in this way.

I have read all related posts on this forum and examples related to
multi_usrp in gnuradio_examples but I am unable to understand where I am
doing wrong, I could not find an answer even from “USRP_Documentation”,
so
please let me know after having a look on code (For code please go above
to
first post on this page) where I am doing wrong.

Do I need to take care of decimation rate when I have two RX channels, I
am
using 160 for both (I think only restriction for decim rate is that it
should be equal for both. Is there any thing else?). OR are there some
parameters which need to be handeled differently for 2 RX channels?

My understanding about deinterleaver is that, it will get the input from
USRP as a single stream as follows:
self.connect(self.u,self.deinter)
and will automatically and correctly divide it into two separate
streams,
and we dont need to do anything else, as follows:
self.connect ((self.deinter,0), self.rx_filter, self.fmdemod, self.corr,
self.vec_sink)
self.connect ((self.deinter,1), self.fft_input)

Is this understanding about deinterleaver correct or do I need to do
some
special processing to get these separate streams.

Thanks

Kaleem AHmad

kaleem ahmad wrote:

I want to use 2 RFX2400 cards. Overall I will have 2 RX streams and 1 TX
self.subdev = (self.u.db[0][0] , self.u.db[1][0])
self.subdev[0].select_rx_antenna( ‘RX2’)
self.connect ((self.deinter,1), self.fft_input) #Other RX antenna for fft
window, this fft will be further processed

http://www.nabble.com/file/p24305532/receive_path.py receive_path.py

Best Regards

–
View this message in context:
http://www.nabble.com/2-RX-and-1-TX-channel-tp24305532p24319015.html
Sent from the GnuRadio mailing list archive at Nabble.com.

4

Hello all,

After lot of efforts I am able to receive some data one one of the RX
channels, but it is too bad. To understand how weak it is, for example,
I
was actually transmitting a already known data string and then on
reception
I was comparing it bit-by-bit with the actual packet and in this way I
was
calculating bit error rate and in case of lost packet I was calculating
packet loss rate. It was an already written code for songle RX channel
and
my BER was around 1.5% and PLR was also around 1.5%. But with two RX
channels both these parameters are abouve 10%.

I am unable to understand what should I do to receive better data (of
same
order as in the case of single RX channel) when I have two RX
channels???

Please let me know if I am doing something wrong. I am tried every
possibility!!!

Best Regards

kaleem ahmad wrote:

special processing to get these separate streams.

should be the value of mux (I am setting 0x3210) and what should be the

look on that, TX-path is not here). I am unable to receive anything from
#Set the gain to the midway point
self.deinter = gr.deinterleave(gr.sizeof_gr_complex)

http://www.nabble.com/file/p24305532/receive_path.py receive_path.py

Best Regards

–
View this message in context:
http://www.nabble.com/2-RX-and-1-TX-channel-tp24305532p24352988.html
Sent from the GnuRadio mailing list archive at Nabble.com.

5

Thanks Jason,

To make the things simple I have first tried sensing with a single
channel
(This code is well known and some where available on this forum or
GNURadio
examples), it is working fine. In this code I simply display the maximum
value of each FFT scan. When I have some data source at the frequency
which
I have set (2.41GHz at the moment) then I can easily see it.

This code is attached as “sensing_single_RX_channel.py” at the end

Then I changed this code for two RX channels, one one path I kept the
same
graph for sensing and the output of other graph is sent to a file. If I
forget the output of file for the time being and focus on other leg of
the
graph i.e. spectrum sensing even then my sensed signal is too weak. For
example if with one RX version I was receiving value ‘75’ then now I am
receiving only ‘10’!!!

This 2 RX channel version is also attached as “sensing_2_RX_channel.py”

Its very easy to run these files on your system.

Can some one help me to find what is the problem.

Thanks

http://www.nabble.com/file/p24355576/sensing_2_RX_channel.py
sensing_2_RX_channel.py
http://www.nabble.com/file/p24355576/sensing_single_RX_channel.py
sensing_single_RX_channel.py

View this message in context:
http://www.nabble.com/2-RX-and-1-TX-channel-tp24305532p24355576.html
Sent from the GnuRadio mailing list archive at Nabble.com.

6

I think that you have the de-interleaving and the mux set up correctly
provided you are using a complex source, but there may be other
problems with your set up that I’m not aware of with regards to those
problems.

I think one problem might be your use of a vector sink as a receiver,
usually the only use for the vector sink is when we are building
testbenches for custom blocks, I would try to save the data to a file
and analyze it using matlab or octave.

As for :

It was an already written code for songle RX channel and
my BER was around 1.5% and PLR was also around 1.5%. But with two RX
channels both these parameters are abouve 10%

I would suggest that your take your USRP code from your first message,
and rather than sending the de-interleaved data to your
filter/correlator/vector sink and testing the PLR that you connect
that directly to the code inside the benchmark_*x.py (I assume that’s
what you mean by ‘already written code for single RX channel’). You
can even just run the second channel to a NULL sink temporarily so you
can focus on getting the de-interleaving working properly. This way
you have a solid base for comparison between the 1 channel and 2
channel cases (they should be the same, it’s the same transmitted data
and same receive process).

Jason