Hello all,
For an experiment I’m working on I need to transmit an OFDM signal
from
one USRP and ‘respond’ from another USRP with an OFDM message with
(hopefully) millisecond timing. I’ve used elements of
benchmark_ofdm_tx/rx and the tunnel examples to construct the following:
USRP A | USRP B
begin carrier sensing |
|
carrier sensed = True | send 50 pkts
… | …
carrier sensed = False | done sending
send 50 pkts | receive and wait ~.5 seconds
repeat | repeat
Both USRPs have a TX graph and an RX graph running. The TX path is the
same as the one in the benchmark_ofdm_tx files. The RX path goes to a
custom OFDM module which doesnt demod packets, but only provides carrier
sense. The rx_graph looks something like this:
self.rxpath = receive_path(self, callback, options)
self.connect(self.u, self.rxpath)
self.logfile = gr.file_sink(gr.sizeof_short, “/mnt/rd/logfile” +
str(self._usrpnum) + “dat”)
self.ctolshort = gr.complex_to_interleaved_short()syn
self.connect(self.u, self.ctolshort, self.logfile)
The receive_path goes up to the ofdm_recv.chan_filt, so that the
gr.probe_avg_mag_sqrd_c can provide carrier sense. I had to cut out the
demod, as it seemed to slow down each side so much that I’d have an
abundance of underruns. Right now I just constantly record the data from
each side to a file, then later run it through a script to demod and
correlate the timings.
The script above runs OK at a decimation of 12, interpolation of 24 and
200 occupied tones. I only get one uO every 10000 pkts or so, which is
acceptably low. However, if I run it with -d 10 and -i 20, I get a uO
every 50 pkts and no usable data.
I’ve done everything I can to speed up the hard disk side of the
equation by creating a RAID 0, running on both XFS and EXT2 with the
fastest options I can find. However, it doesnt seem as if the drive
writes are the issue. If I remove the file_sink or close the file socket
while running, I still receive the uOs. I’ve kept track of both my RAM
and CPU, but neither are maxing out during the runs, so I dont believe
that’s the problem either.
Basically, I want to run a tx and rx path at the same time on two USRPs,
with the lowest decimation possible. I need to send from one and respond
from the other within milliseconds. Any suggestions on how to reduce the
number of uOs? Or a different approach?
Thanks,
Dev