def __init__(self,options,Freq): gr.top_block.__init__(self) if options.input_file == "": self.IS_USRP2 = True else: self.IS_USRP2 = False #self.min_freq = options.start #self.max_freq = options.stop self.min_freq = Freq.value-(3*10**6) # same as that of the transmitter bandwidth ie 6MHZ approx for a given value of decimation line option any more self.max_freq = Freq.value+(3*10**6) if self.min_freq > self.max_freq: self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them print "Start and stop frequencies order swapped!" self.fft_size = options.fft_size self.ofdm_bins = options.sense_bins # build graph s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) power = 0 for tap in mywindow: power += tap*tap c2mag = gr.complex_to_mag_squared(self.fft_size) #log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) # modifications for USRP2 if self.IS_USRP2: self.u = uhd.usrp_source(options.args,uhd.io_type.COMPLEX_FLOAT32,num_channels=1) # Modified Line # self.u.set_decim(options.decim) # samp_rate = self.u.adc_rate()/self.u.decim() samp_rate = 100e6/options.decim # modified sampling rate self.u.set_samp_rate(samp_rate) else: self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True) samp_rate = 100e6 /options.decim # modified sampling rate self.freq_step =0 #0.75* samp_rate self.min_center_freq = (self.min_freq + self.max_freq)/2 global BW BW = self.max_freq - self.min_freq global size size=self.fft_size global ofdm_bins ofdm_bins = self.ofdm_bins global usr #global thrshold_inorder usr=samp_rate nsteps = 10 self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames self.msgq = gr.msg_queue(16) # thread-safe message queue self._tune_callback = tune(self) # hang on to this to keep it from being GC'd stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay) # control scanning and record frequency domain statistics self.connect(self.u, s2v, fft,c2mag,stats) if options.gain is None: g = self.u.get_gain_range() options.gain = float(g.start()+g.stop())/2 # if no gain was specified, use the mid-point in dB
def xtest_004(self):
vlen = 4
tune = counter4(self, 1)
tune_delay = 1
dwell_delay = 2
msgq = gr.msg_queue()
src_data = tuple([
float(x)
for x in (1, 2, 3, 4, 9, 6, 11, 8, 5, 10, 7, 12, 13, 14, 15, 16)
])
expected_results = tuple([float(x) for x in (9, 10, 11, 12)])
src = gr.vector_source_f(src_data, False)
s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
stats = gr.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay)
self.tb.connect(src, s2v, stats)
self.tb.run()
self.assertEqual(1, msgq.count())
for i in range(1):
m = parse_msg(msgq.delete_head())
#print "m =", m.center_freq, m.data
self.assertEqual(expected_results[vlen * i:vlen * i + vlen],
m.data)
def xtest_004(self):
vlen = 4
tune = counter4(self, 1)
tune_delay = 1
dwell_delay = 2
msgq = gr.msg_queue()
src_data = tuple([float(x) for x in
( 1, 2, 3, 4,
9, 6, 11, 8,
5, 10, 7, 12,
13, 14, 15, 16
)])
expected_results = tuple([float(x) for x in
( 9, 10, 11, 12)])
src = gr.vector_source_f(src_data, False)
s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
stats = gr.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay)
self.tb.connect(src, s2v, stats)
self.tb.run()
self.assertEqual(1, msgq.count())
for i in range(1):
m = parse_msg(msgq.delete_head())
#print "m =", m.center_freq, m.data
self.assertEqual(expected_results[vlen*i:vlen*i + vlen], m.data)
def __init__(self,options,Freq): gr.top_block.__init__(self) if options.input_file == "": self.IS_USRP2 = True else: self.IS_USRP2 = False #self.min_freq = options.start #self.max_freq = options.stop self.min_freq = Freq.value-(3*10**6) # same as that of the transmitter bandwidth ie 6MHZ approx for a given value of decimation line option any more self.max_freq = Freq.value+(3*10**6) if self.min_freq > self.max_freq: self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them print "Start and stop frequencies order swapped!" self.fft_size = options.fft_size self.ofdm_bins = options.sense_bins # build graph s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) power = 0 for tap in mywindow: power += tap*tap c2mag = gr.complex_to_mag_squared(self.fft_size) #log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) # modifications for USRP2 if self.IS_USRP2: self.u = uhd.usrp_source(options.args,uhd.io_type.COMPLEX_FLOAT32,num_channels=1) # Modified Line # self.u.set_decim(options.decim) # samp_rate = self.u.adc_rate()/self.u.decim() samp_rate = 100e6/options.decim # modified sampling rate self.u.set_samp_rate(samp_rate) else: self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True) samp_rate = 100e6 /options.decim # modified sampling rate self.freq_step =0 #0.75* samp_rate self.min_center_freq = (self.min_freq + self.max_freq)/2 global BW BW = self.max_freq - self.min_freq global size size=self.fft_size global ofdm_bins ofdm_bins = self.ofdm_bins global usr #global thrshold_inorder usr=samp_rate nsteps = 10 #math.ceil((self.max_freq - self.min_freq) / self.freq_step) self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames self.msgq = gr.msg_queue(16) # thread-safe message queue self._tune_callback = tune(self) # hang on to this to keep it from being GC'd stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay) # control scanning and record frequency domain statistics self.connect(self.u, s2v, fft,c2mag,stats) if options.gain is None: g = self.u.get_gain_range() options.gain = float(g.start()+g.stop())/2 # if no gain was specified, use the mid-point in dB
def __init__(self):
sense_band_start=900*10**6
sense_band_stop=940*10**6
self.fft_size = options.fft_size
self.ofdm_bins = options.sense_bins
# build graph
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
#log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# modifications for USRP2
print "*******************in sensor init********************"
if self.IS_USRP2:
self.u = usrp2.source_32fc(options.interface, options.MAC_addr)
self.u.set_decim(options.decim)
samp_rate = self.u.adc_rate() / self.u.decim()
else:
self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True)
samp_rate = 100e6 / options.decim
self.freq_step =0.75* samp_rate
#self.min_center_freq = (self.min_freq + self.max_freq)/2
global BW
BW = 0.75* samp_rate #self.max_freq - self.min_freq
global size
size=self.fft_size
global ofdm_bins
ofdm_bins = self.ofdm_bins
global usr
#global thrshold_inorder
usr=samp_rate
nsteps = 10 #math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames
print tune_delay
dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames
print dwell_delay
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self)
# hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay,
dwell_delay)
self.connect(self.u, s2v, fft,c2mag,stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.gain_range()
options.gain = float(g[0]+g[1])/2
def __init__(self, usrp_rate, tuner_callback, options):
gr.hier_block2.__init__(self, "sense_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
self.usrp_rate = usrp_rate
self.usrp_tune = tuner_callback
self.num_tests = options.num_tests
self.threshold = options.threshold
self.min_freq = options.start_freq
self.max_freq = options.end_freq
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
# build graph
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#changed on 2011 May 31, MR -- maybe change back at some point
self.freq_step = self.usrp_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * self.usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * self.usrp_rate / self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self, s2v, fft, c2mag, log, stats)
self.connect(self, s2v, fft, c2mag, stats)
def __init__(self):
gr.top_block.__init__(self)
usage = "usage: %prog [options] min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0,0),
help="select USRP Rx side A or B (default=A)")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("", "--tune-delay", type="eng_float", default=.01, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=.05, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=1024,
help="specify number of FFT bins [default=%default]")
#updated 2011 May 27, MR
parser.add_option("-s", "--samp_rate", type="intx", default=6000000,
help="set sample rate to SAMP_RATE [default=%default]")
parser.add_option("", "--chan-bandwidth", type="intx", default=6000000,
help="set channel bw [default=%default]")
#parser.add_option("-d", "--decim", type="intx", default=16,
# help="set decimation to DECIM [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
#parser.add_option("-B", "--fusb-block-size", type="int", default=0,
# help="specify fast usb block size [default=%default]")
#parser.add_option("-N", "--fusb-nblocks", type="int", default=0,
# help="specify number of fast usb blocks [default=%default]")
#options added 2011 May 31, MR
parser.add_option("", "--threshold", type="eng_float", default=-70,
help="set detection threshold [default=%default]")
parser.add_option("", "--num-tests", type="intx", default=200,
help="set the number of times to test the frequency band [default=%default]")
parser.add_option("", "--log-file", action="store_true", default=False,
help="log output to a file")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
self.num_tests = options.num_tests
self.threshold = options.threshold
self.samp_rate = options.samp_rate
self.min_freq = eng_notation.str_to_num(args[0])
self.max_freq = eng_notation.str_to_num(args[1])
self.log_file = options.log_file
self.num_channels = int((self.max_freq - self.min_freq)/self.samp_rate) + 2
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
#removed 2011 May 27, MR
# If the user hasn't set the fusb_* parameters on the command line,
# pick some values that will reduce latency.
#if 1:
# if options.fusb_block_size == 0 and options.fusb_nblocks == 0:
# if realtime: # be more aggressive
# options.fusb_block_size = gr.prefs().get_long('fusb', 'rt_block_size', 1024)
# options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks', 16)
# else:
# options.fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
# options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
#print "fusb_block_size =", options.fusb_block_size
#print "fusb_nblocks =", options.fusb_nblocks
# build graph
#updated 2011 May 27, MR
self.u = uhd.usrp_source(device_addr="", io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=1)
self.u.set_subdev_spec("", 0)
self.u.set_antenna("TX/RX", 0)
self.u.set_samp_rate(options.samp_rate)
#self.u = usrp.source_c(fusb_block_size=options.fusb_block_size,
# fusb_nblocks=options.fusb_nblocks)
#adc_rate = self.u.adc_rate() # 64 MS/s
#usrp_decim = options.decim
#self.u.set_decim_rate(usrp_decim)
self.usrp_rate = self.u.get_samp_rate() #adc_rate / usrp_decim
print "sample rate is", self.usrp_rate
#self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
#self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
print "Using RX d'board %s" % (self.u.get_dboard_sensor_names(chan=0))#(self.subdev.side_and_name(),)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#changed on 2011 May 31, MR -- maybe change back at some point
#self.freq_step = 0.75 * self.usrp_rate
self.freq_step = options.chan_bandwidth
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * self.usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * self.usrp_rate / self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
# updated 2011 May 31, MR
#g = self.subdev.gain_range()
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2
self.set_gain(options.gain)
print "gain =", options.gain
def __init__(self, demod_class, rx_callback, options, source_block):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._bitrate = options.bitrate # desired bit rate
self._rx_callback = rx_callback # this callback is fired when a packet arrives
self._demod_class = demod_class # the demodulator_class we're using
self._chbw_factor = options.chbw_factor # channel filter bandwidth factor
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
#Give hooks of usrp to blocks downstream
self.source_block = source_block
#########################################
# Build Blocks
#########################################
# Build the demodulator
self.demodulator = self._demod_class(**demod_kwargs)
# Make sure the channel BW factor is between 1 and sps/2
# or the filter won't work.
if(self._chbw_factor < 1.0 or self._chbw_factor > self.samples_per_symbol()/2):
sys.stderr.write("Channel bandwidth factor ({0}) must be within the range [1.0, {1}].\n".format(self._chbw_factor, self.samples_per_symbol()/2))
sys.exit(1)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass (1.0, # gain
sw_decim * self.samples_per_symbol(), # sampling rate
self._chbw_factor, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
digital.demod_pkts(self.demodulator,
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
# More Carrier Sensing with FFT
#self.gr_vector_sink = gr.vector_sink_c(1024)
#self.gr_stream_to_vector = gr.stream_to_vector(gr.sizeof_gr_complex*1, 1024)
#self.gr_head = gr.head(gr.sizeof_gr_complex*1024, 1024)
#self.fft = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1)
# Parameters
usrp_rate = options.bitrate
self.fft_size = 1024
self.min_freq = 2.4e9-0.75e6
self.max_freq = 2.4e9+0.75e6
self.tune_delay = 0.001
self.dwell_delay = 0.01
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#self.freq_step = 0.75 * usrp_rate
#self.min_center_freq = self.min_freq + self.freq_step/2
#nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
#self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.freq_step = 1.5e6
self.min_center_freq = self.min_freq
nsteps = 1
self.max_center_freq = self.max_freq
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(self.tune_delay * usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(self.dwell_delay * usrp_rate / self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
######################################################
# Connect Blocks Together
######################################################
#channel-filter-->Probe_Avg_Mag_Sqrd
# -->Packet_Receiver (Demod Done Here!!)
#
# connect FFT sampler to system
#self.connect(self, self.gr_stream_to_vector, self.fft, self.gr_vector_sink)
# connect block input to channel filter
self.connect(self, self.channel_filter)
# connect the channel input filter to the carrier power detector
self.connect(self.channel_filter, self.probe)
# connect channel filter to the packet receiver
self.connect(self.channel_filter, self.packet_receiver)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.channel_filter, s2v, fft, c2mag, stats)
def __init__(self):
gr.top_block.__init__(self)
# Build an options parser to bring in information from the user on usage
usage = "usage: %prog [options] host min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-g", "--gain", type="eng_float", default=32,
help="set gain in dB (default is midpoint)")
parser.add_option("", "--tune-delay", type="eng_float", default=5e-5, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=50e-5, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
(options, args) = parser.parse_args()
if len(args) != 3:
parser.print_help()
sys.exit(1)
# get user-provided info on address of MSDD and frequency to sweep
self.address = args[0]
self.min_freq = eng_notation.str_to_num(args[1])
self.max_freq = eng_notation.str_to_num(args[2])
self.decim = options.decim
self.gain = options.gain
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
# Sampling rate is hardcoded and cannot be read off device
adc_rate = 102.4e6
self.int_rate = adc_rate / self.decim
print "Sampling rate: ", self.int_rate
# build graph
self.port = 10001 # required port for UDP packets
# which board, op mode, adx, port
# self.src = msdd.source_c(0, 1, self.address, self.port) # build source object
self.conv = gr.interleaved_short_to_complex();
self.src = msdd.source_simple(self.address,self.port);
self.src.set_decim_rate(self.decim) # set decimation rate
# self.src.set_desired_packet_size(0, 1460) # set packet size to collect
self.set_gain(self.gain) # set receiver's attenuation
self.set_freq(self.min_freq) # set receiver's rx frequency
# restructure into vector format for FFT input
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
# set up FFT processing block
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow, True)
power = 0
for tap in mywindow:
power += tap*tap
# calculate magnitude squared of output of FFT
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to % of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.percent = 0.4
# Calculate the frequency steps to use in the collection over the whole bandwidth
self.freq_step = self.percent * self.int_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
# use these values to set receiver settling time between samples and sampling time
# the default values provided seem to work well with the MSDD over 100 Mbps ethernet
tune_delay = max(0, int(round(options.tune_delay * self.int_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * self.int_rate / self.fft_size))) # in fft_frames
# set up message callback routine to get data from bin_statistics_f block
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
# FIXME this block doesn't like to work with negatives because of the "d_max[i]=0" on line
# 151 of gr_bin_statistics_f.cc file. Set this to -10000 or something to get it to work.
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME there's a concern over the speed of the log calculation
# We can probably calculate the log inside the stats block
self.connect(self.src, self.conv, s2v, fft, c2mag, log, stats)
def __init__(self):
gr.top_block.__init__(self)
global parser
parser = OptionParser(option_class=eng_option)
parser.add_option("-a",
"--args",
type="string",
default="",
help="UHD device address [default=%default]")
#parser.add_option("-e", "--interface", type="string", default="eth0", help="Select ethernet interface. Default is eth0")
#parser.add_option("-m", "--MAC_addr", type="string", default="", help="Select USRP2 by its MAC address.Default is auto-select")
parser.add_option("-p",
"--start",
type="eng_float",
default=1e7,
help="Start ferquency [default = %default]")
parser.add_option("-q",
"--stop",
type="eng_float",
default=1e8,
help="Stop ferquency [default = %default]")
parser.add_option(
"",
"--tune-delay",
type="eng_float",
default=1e-3,
metavar="SECS",
help=
"time to delay (in seconds) after changing frequency[default=%default]"
)
parser.add_option(
"",
"--dwell-delay",
type="eng_float",
default=10e-3,
metavar="SECS",
help=
"time to dwell (in seconds) at a given frequncy[default=%default]")
parser.add_option("-g",
"--gain",
type="eng_float",
default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("-s",
"--fft-size",
type="int",
default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d",
"--decim",
type="intx",
default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("-i",
"--input_file",
default="",
help="radio input file",
metavar="FILE")
parser.add_option(
"-S",
"--sense-bins",
type="int",
default=64,
help="set number of bins in the OFDM block [default=%default]")
(options, args) = parser.parse_args()
if options.input_file == "":
self.IS_USRP2 = True
else:
self.IS_USRP2 = False
self.min_freq = options.start
self.max_freq = options.stop
print "min_freq=", self.min_freq
print "max_freq=", self.max_freq
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
print "Start and stop frequencies order swapped!"
self.fft_size = options.fft_size
self.ofdm_bins = options.sense_bins
# build graph
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap * tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
#log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# modifications for USRP2
print "*******************in sensor init********************"
if self.IS_USRP2:
self.u = uhd.usrp_source(device_addr=options.args,
io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1)
samp_rate = 100**6 / options.decim
self.u.set_samp_rate(samp_rate)
else:
self.u = gr.file_source(gr.sizeof_gr_complex, options.input_file,
True)
samp_rate = 100e6 / options.decim
self.freq_step = 0 #0.75* samp_rate
self.min_center_freq = (self.min_freq + self.max_freq) / 2
global BW
BW = self.max_freq - self.min_freq
print "bandwidth=", BW
global size
size = self.fft_size
global ofdm_bins
ofdm_bins = self.ofdm_bins
global usr
#global thrshold_inorder
usr = samp_rate
nsteps = 10 #math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0,
int(
round(options.tune_delay * samp_rate /
self.fft_size))) # in fft_frames
print tune_delay
dwell_delay = max(1,
int(
round(options.dwell_delay * samp_rate /
self.fft_size))) # in fft_frames
print dwell_delay
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self)
# hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start() + g.stop()) / 2
def __init__(self):
gr.top_block.__init__(self)
usage = "usage: %prog [options] min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0,0),
help="select USRP Rx side A or B (default=A)")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("", "--tune-delay", type="eng_float", default=1e-4, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=1e-3, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
parser.add_option("-f", "--freq", type="eng_float",
default = 5.2e9, help="set USRP2 carrier frequency, [default=%default]",
metavar="FREQ")
(options, args) = parser.parse_args()
#if len(args) != 2:
#parser.print_help()
#sys.exit(1)
#self.min_freq = eng_notation.str_to_num(args[0])
#self.max_freq = eng_notation.str_to_num(args[1])
self.min_freq = options.freq
self.max_freq = options.freq
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
#build graph
self.u = usrp2.source_32fc()
adc_rate = self.u.adc_rate() # 64 MS/s
usrp2_decim = options.decim
self.u.set_decim(usrp2_decim)
usrp2_rate = adc_rate / usrp2_decim
#self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
#self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
#print "Using RX d'board %s" % (self.subdev.side_and_name(),)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.freq_step = 0.75 * usrp2_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * usrp2_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * usrp2_rate / self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.gain_range()
#options.gain = float(g[0]+g[1])/2
options.gain = max(min(options.gain, g[1]), g[0] )
self.u.set_gain(options.gain)
def __init__(self):
gr.top_block.__init__(self)
usage = "usage: %prog [options] min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-a", "--args", type="string", default="",
help="UHD device device address args [default=%default]")
parser.add_option("", "--spec", type="string", default=None,
help="Subdevice of UHD device where appropriate")
parser.add_option("-A", "--antenna", type="string", default=None,
help="select Rx Antenna where appropriate")
parser.add_option("-s", "--samp-rate", type="eng_float", default=1e6,
help="set sample rate [default=%default]")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("", "--tune-delay", type="eng_float",
default=1e-3, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float",
default=10e-3, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
self.min_freq = eng_notation.str_to_num(args[0])
self.max_freq = eng_notation.str_to_num(args[1])
if self.min_freq > self.max_freq:
# swap them
self.min_freq, self.max_freq = self.max_freq, self.min_freq
self.fft_size = options.fft_size
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
# build graph
self.u = uhd.usrp_source(device_addr=options.args,
stream_args=uhd.stream_args('fc32'))
# Set the subdevice spec
if(options.spec):
self.u.set_subdev_spec(options.spec, 0)
# Set the antenna
if(options.antenna):
self.u.set_antenna(options.antenna, 0)
usrp_rate = options.samp_rate
self.u.set_samp_rate(usrp_rate)
dev_rate = self.u.get_samp_rate()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.freq_step = 0.75 * usrp_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * usrp_rate / self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.0
self.set_gain(options.gain)
print "gain =", options.gain
def __init__(self):
gr.top_block.__init__(self)
# Build an options parser to bring in information from the user on usage
usage = "usage: %prog [options] host min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-g",
"--gain",
type="eng_float",
default=32,
help="set gain in dB (default is midpoint)")
parser.add_option(
"",
"--tune-delay",
type="eng_float",
default=5e-5,
metavar="SECS",
help=
"time to delay (in seconds) after changing frequency [default=%default]"
)
parser.add_option(
"",
"--dwell-delay",
type="eng_float",
default=50e-5,
metavar="SECS",
help=
"time to dwell (in seconds) at a given frequncy [default=%default]"
)
parser.add_option("-F",
"--fft-size",
type="int",
default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d",
"--decim",
type="intx",
default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("",
"--real-time",
action="store_true",
default=False,
help="Attempt to enable real-time scheduling")
(options, args) = parser.parse_args()
if len(args) != 3:
parser.print_help()
sys.exit(1)
# get user-provided info on address of MSDD and frequency to sweep
self.address = args[0]
self.min_freq = eng_notation.str_to_num(args[1])
self.max_freq = eng_notation.str_to_num(args[2])
self.decim = options.decim
self.gain = options.gain
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
# Sampling rate is hardcoded and cannot be read off device
adc_rate = 102.4e6
self.int_rate = adc_rate / self.decim
print "Sampling rate: ", self.int_rate
# build graph
self.port = 10001 # required port for UDP packets
# which board, op mode, adx, port
# self.src = msdd.source_c(0, 1, self.address, self.port) # build source object
self.conv = gr.interleaved_short_to_complex()
self.src = msdd.source_simple(self.address, self.port)
self.src.set_decim_rate(self.decim) # set decimation rate
# self.src.set_desired_packet_size(0, 1460) # set packet size to collect
self.set_gain(self.gain) # set receiver's attenuation
self.set_freq(self.min_freq) # set receiver's rx frequency
# restructure into vector format for FFT input
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
# set up FFT processing block
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow, True)
power = 0
for tap in mywindow:
power += tap * tap
# calculate magnitude squared of output of FFT
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(
10, self.fft_size, -20 * math.log10(self.fft_size) -
10 * math.log10(power / self.fft_size))
# Set the freq_step to % of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.percent = 0.4
# Calculate the frequency steps to use in the collection over the whole bandwidth
self.freq_step = self.percent * self.int_rate
self.min_center_freq = self.min_freq + self.freq_step / 2
nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
# use these values to set receiver settling time between samples and sampling time
# the default values provided seem to work well with the MSDD over 100 Mbps ethernet
tune_delay = max(0,
int(
round(options.tune_delay * self.int_rate /
self.fft_size))) # in fft_frames
dwell_delay = max(1,
int(
round(options.dwell_delay * self.int_rate /
self.fft_size))) # in fft_frames
# set up message callback routine to get data from bin_statistics_f block
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(
self) # hang on to this to keep it from being GC'd
# FIXME this block doesn't like to work with negatives because of the "d_max[i]=0" on line
# 151 of gr_bin_statistics_f.cc file. Set this to -10000 or something to get it to work.
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
# FIXME there's a concern over the speed of the log calculation
# We can probably calculate the log inside the stats block
self.connect(self.src, self.conv, s2v, fft, c2mag, log, stats)
def __init__(self):
gr.top_block.__init__(self)
usage = "usage: %prog [options] min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0,0),
help="select USRP Rx side A or B (default=A)")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=10e-3, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
parser.add_option("-B", "--fusb-block-size", type="int", default=0,
help="specify fast usb block size [default=%default]")
parser.add_option("-N", "--fusb-nblocks", type="int", default=0,
help="specify number of fast usb blocks [default=%default]")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
self.min_freq = eng_notation.str_to_num(args[0])
self.max_freq = eng_notation.str_to_num(args[1])
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
# If the user hasn't set the fusb_* parameters on the command line,
# pick some values that will reduce latency.
if 1:
if options.fusb_block_size == 0 and options.fusb_nblocks == 0:
if realtime: # be more aggressive
options.fusb_block_size = gr.prefs().get_long('fusb', 'rt_block_size', 1024)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks', 16)
else:
options.fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
#print "fusb_block_size =", options.fusb_block_size
#print "fusb_nblocks =", options.fusb_nblocks
# build graph
self.u = usrp.source_c(fusb_block_size=options.fusb_block_size,
fusb_nblocks=options.fusb_nblocks)
adc_rate = self.u.adc_rate() # 64 MS/s
usrp_decim = options.decim
self.u.set_decim_rate(usrp_decim)
usrp_rate = adc_rate / usrp_decim
self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
print "Using RX d'board %s" % (self.subdev.side_and_name(),)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.freq_step = 0.75 * usrp_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * usrp_rate / self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
options.gain = float(g[0]+g[1])/2
self.set_gain(options.gain)
print "gain =", options.gain
def __init__(self,options,Freq):
gr.top_block.__init__(self)
#global parser
#parser = OptionParser(option_class=eng_option)
#parser.add_option("-e", "--interface", type="string", default="eth0", help="Select ethernet interface. Default is eth0")
#parser.add_option("-m", "--MAC_addr", type="string", default="", help="Select USRP2 by its MAC address.Default is auto-select")
#parser.add_option("-a", "--start", type="eng_float", default=1e7, help="Start ferquency [default = %default]")
#parser.add_option("-b", "--stop", type="eng_float", default=1e8,help="Stop ferquency [default = %default]")
#parser.add_option("", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS", help="time to delay (in seconds) after changing frequency[default=%default]")
#parser.add_option("", "--dwell-delay", type="eng_float",default=10e-3, metavar="SECS", help="time to dwell (in seconds) at a given frequncy[default=%default]")
#parser.add_option("-g", "--gain", type="eng_float", default=None,help="set gain in dB (default is midpoint)")
#parser.add_option("-s", "--fft-size", type="int", default=256, help="specify number of FFT bins [default=%default]")
#parser.add_option("-d", "--decim", type="intx", default=16, help="set decimation to DECIM [default=%default]")
#parser.add_option("-i", "--input_file", default="", help="radio input file",metavar="FILE")
#parser.add_option("-S", "--sense-bins", type="int", default=64, help="set number of bins in the OFDM block [default=%default]")
#(options, args) = parser.parse_args()
if options.input_file == "":
self.IS_USRP2 = True
else:
self.IS_USRP2 = False
#self.min_freq = options.start
#self.max_freq = options.stop
#print "min_freq=",self.min_freq
#print "max_freq=",self.max_freq
self.min_freq = Freq.value-(3*10**6) #hard coded not a command line option any more
self.max_freq = Freq.value+(3*10**6)
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
print "Start and stop frequencies order swapped!"
self.fft_size = options.fft_size
self.ofdm_bins = options.sense_bins
# build graph
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
#log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# modifications for USRP2
print "*******************in sensor init********************"
if self.IS_USRP2:
self.u=uhd.usrp_source(device_addr=options.args,io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1)
samp_rate = 100**6/options.decim
self.u.set_samp_rate(samp_rate)
else:
self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True)
samp_rate = 100e6 / options.decim
self.freq_step =0 #0.75* samp_rate
self.min_center_freq = (self.min_freq + self.max_freq)/2
global BW
BW = self.max_freq - self.min_freq
print "bandwidth=",BW
global size
size=self.fft_size
global ofdm_bins
ofdm_bins = self.ofdm_bins
global usr
#global thrshold_inorder
usr=samp_rate
nsteps = 10 #math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames
print tune_delay
dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames
print dwell_delay
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self)
# hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay,
dwell_delay)
self.connect(self.u, s2v, fft,c2mag,stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2
def __init__(self, tuner_callback, options):
gr.hier_block2.__init__(
self,
"sense_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
self.usrp_rate = options.channel_rate
self.usrp_tune = tuner_callback
self.threshold = options.threshold
#self.freq_step = options.chan_bandwidth
#self.min_freq = options.start_freq
#self.max_freq = options.end_freq
self.hold_freq = False
self.channels = [
600000000, 620000000, 625000000, 640000000, 645000000, 650000000
]
self.current_chan = 0
self.num_channels = len(
self.channels) #(self.max_freq - self.min_freq)/self.freq_step
#if self.min_freq > self.max_freq:
# self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.sense_fft_size
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
# build graph
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap * tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(
10, self.fft_size, -20 * math.log10(self.fft_size) -
10 * math.log10(power / self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#changed on 2011 May 31, MR -- maybe change back at some point
#self.min_center_freq = self.min_freq + self.freq_step/2
#nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
#self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.channels[
self.current_chan] #self.min_center_freq
tune_delay = max(0,
int(
round(options.tune_delay * self.usrp_rate /
self.fft_size))) # in fft_frames
dwell_delay = max(1,
int(
round(options.dwell_delay * self.usrp_rate /
self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(
self) # hang on to this to keep it from being GC'd
self.stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self, s2v, fft, c2mag, log, stats)
self.connect(self, s2v, fft, c2mag, self.stats)
def __init__(self):
gr.top_block.__init__(self)
usage = "usage: %prog [options] min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-a", "--args", type="string", default="",
help="UHD device device address args [default=%default]")
parser.add_option("", "--spec", type="string", default=None,
help="Subdevice of UHD device where appropriate")
parser.add_option("-A", "--antenna", type="string", default=None,
help="select Rx Antenna where appropriate")
parser.add_option("-s", "--samp-rate", type="eng_float", default=1e6,
help="set sample rate [default=%default]")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("", "--tune-delay", type="eng_float",
default=1e-3, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float",
default=10e-3, metavar="SECS",
help="time to dwell (in seconds) at a given frequency [default=%default]")
parser.add_option("", "--channel-bandwidth", type="eng_float",
default=12.5e3, metavar="Hz",
help="channel bandwidth of fft bins in Hz [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
self.min_freq = eng_notation.str_to_num(args[0])
self.max_freq = eng_notation.str_to_num(args[1])
if self.min_freq > self.max_freq:
# swap them
self.min_freq, self.max_freq = self.max_freq, self.min_freq
self.fft_size = options.fft_size
self.channel_bandwidth = options.channel_bandwidth
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
# build graph
self.u = uhd.usrp_source(device_addr=options.args,
stream_args=uhd.stream_args('fc32'))
# Set the subdevice spec
if(options.spec):
self.u.set_subdev_spec(options.spec, 0)
# Set the antenna
if(options.antenna):
self.u.set_antenna(options.antenna, 0)
self.usrp_rate = usrp_rate = options.samp_rate
self.u.set_samp_rate(usrp_rate)
dev_rate = self.u.get_samp_rate()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow, True)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.freq_step = 0.75 * usrp_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * usrp_rate / self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.0
self.set_gain(options.gain)
print "gain =", options.gain
def __init__(self, demod_class, rx_callback, options, source_block):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
options = copy.copy(
options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._bitrate = options.bitrate # desired bit rate
self._rx_callback = rx_callback # this callback is fired when a packet arrives
self._demod_class = demod_class # the demodulator_class we're using
self._chbw_factor = options.chbw_factor # channel filter bandwidth factor
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
#Give hooks of usrp to blocks downstream
self.source_block = source_block
#########################################
# Build Blocks
#########################################
# Build the demodulator
self.demodulator = self._demod_class(**demod_kwargs)
# Make sure the channel BW factor is between 1 and sps/2
# or the filter won't work.
if (self._chbw_factor < 1.0
or self._chbw_factor > self.samples_per_symbol() / 2):
sys.stderr.write(
"Channel bandwidth factor ({0}) must be within the range [1.0, {1}].\n"
.format(self._chbw_factor,
self.samples_per_symbol() / 2))
sys.exit(1)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass(
1.0, # gain
sw_decim * self.samples_per_symbol(), # sampling rate
self._chbw_factor, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
digital.demod_pkts(self.demodulator,
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh, alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
# More Carrier Sensing with FFT
#self.gr_vector_sink = gr.vector_sink_c(1024)
#self.gr_stream_to_vector = gr.stream_to_vector(gr.sizeof_gr_complex*1, 1024)
#self.gr_head = gr.head(gr.sizeof_gr_complex*1024, 1024)
#self.fft = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1)
# Parameters
usrp_rate = options.bitrate
self.fft_size = 1024
self.min_freq = 2.4e9 - 0.75e6
self.max_freq = 2.4e9 + 0.75e6
self.tune_delay = 0.001
self.dwell_delay = 0.01
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap * tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(
10, self.fft_size, -20 * math.log10(self.fft_size) -
10 * math.log10(power / self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#self.freq_step = 0.75 * usrp_rate
#self.min_center_freq = self.min_freq + self.freq_step/2
#nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
#self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.freq_step = 1.5e6
self.min_center_freq = self.min_freq
nsteps = 1
self.max_center_freq = self.max_freq
self.next_freq = self.min_center_freq
tune_delay = max(0,
int(round(self.tune_delay * usrp_rate /
self.fft_size))) # in fft_frames
dwell_delay = max(1,
int(
round(self.dwell_delay * usrp_rate /
self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(
self) # hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
######################################################
# Connect Blocks Together
######################################################
#channel-filter-->Probe_Avg_Mag_Sqrd
# -->Packet_Receiver (Demod Done Here!!)
#
# connect FFT sampler to system
#self.connect(self, self.gr_stream_to_vector, self.fft, self.gr_vector_sink)
# connect block input to channel filter
self.connect(self, self.channel_filter)
# connect the channel input filter to the carrier power detector
self.connect(self.channel_filter, self.probe)
# connect channel filter to the packet receiver
self.connect(self.channel_filter, self.packet_receiver)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.channel_filter, s2v, fft, c2mag, stats)
def __init__(self):
gr.top_block.__init__(self)
usage = "usage: %prog [options] host min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("", "--tune-delay", type="eng_float", default=5e-5, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=50e-5, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
(options, args) = parser.parse_args()
if len(args) != 3:
parser.print_help()
sys.exit(1)
self.address = args[0]
self.min_freq = eng_notation.str_to_num(args[1])
self.max_freq = eng_notation.str_to_num(args[2])
self.decim = options.decim
self.gain = options.gain
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
adc_rate = 102.4e6
self.int_rate = adc_rate / self.decim
print "Sampling rate: ", self.int_rate
# build graph
self.port = 10001
self.src = msdd.source_simple(self.address, self.port)
self.src.set_decim_rate(self.decim)
self.set_gain(self.gain)
self.set_freq(self.min_freq)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow, True)
power = 0
for tap in mywindow:
power += tap*tap
norm = gr.multiply_const_cc(1.0/self.fft_size)
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to % of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.percent = 0.4
self.freq_step = self.percent * self.int_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * self.int_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * self.int_rate / self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME leave out the log10 until we speed it up
self.connect(self.src, s2v, fft, c2mag, log, stats)
def __init__(self,options):
gr.top_block.__init__(self)
self.min_freq = options.freq
self.max_freq = options.freq #Only one power's measurement at one frequency
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # Swap them
self.fft_size = options.fft_size
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
# Build carrier sensing graph
#self.u = usrp2.source_32fc()
self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
#adc_rate = self.u.adc_rate()
usrp_decim = options.decim
#self.u.set_decim(usrp2_decim)
usrp_rate = 1e8 / usrp_decim
self.u.set_samp_rate(usrp_rate)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
# Blackman-Harris was the default window type of the original application 'USRP Spectrum Sense'
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.freq_step = 0.75 * usrp_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * usrp_rate / self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self)
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the USRP2 mid-point in dB
g = self.u.gain_range()
options.gain = max(min(options.gain, g[1]), g[0] )
self.u.set_gain(options.gain)