When I implement the source code " usrp_spectrum_sense.py", the program
can
be compile but when I enter the start, end frequency and fft size it
comes
with a error:‘module’ object has no attribute ’stream_to_vector. Has
anyone
meet this error before.
and I found some solution : rename the project file and delete
filename.pyc
if exists, but I don’t know where to find the .pyc file for the
stream_to_vector, is it included in gr?
Any direction or examples will be very helpful for me.
Thanks a lot
Huihuang
http://gnuradio.4.n7.nabble.com/file/n51288/error.png
here I attached the program
from gnuradio import gr, eng_notation
from gnuradio import audio
from gnuradio.fft import window
from gnuradio import uhd
from gnuradio.eng_option import eng_option
from optparse import OptionParser
import sys
import math
import struct
from gnuradio import blocks
from gnuradio import wxgui
import threading
sys.stderr.write(“test usrp_sense->huihuang.\n\n”)
class ThreadClass(threading.Thread):
def run(self):
return
class tune(gr.feval_dd):
“”"
This class allows C++ code to callback into python.
“”"
def init(self, tb):
gr.feval_dd.init(self)
self.tb = tb
def eval(self, ignore):
"""
This method is called from gr.bin_statistics_f when it wants to
change
the center frequency. This method tunes the front end to the
new
center
frequency, and returns the new frequency as its result.
“”"
try:
# We use this try block so that if something goes wrong from
here
# down, at least we’ll have a prayer of knowing what went
wrong.
# Without this, you get a very mysterious:
#
# terminate called after throwing an instance of
‘Swig::DirectorMethodException’
# Aborted
#
# message on stderr. Not exactly helpful 
new_freq = self.tb.set_next_freq()
return new_freq
except Exception, e:
print "tune: Exception: ", e
class parse_msg(object):
def init(self, msg):
self.center_freq = msg.arg1()
self.vlen = int(msg.arg2())
assert(msg.length() == self.vlen * gr.sizeof_float)
# FIXME consider using Numarray or NumPy vector
t = msg.to_string()
self.raw_data = t
self.data = struct.unpack('%df' % (self.vlen,), t)
class my_top_block(gr.top_block):
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 the gain in dB[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
frequency[default=%default]”)
parser.add_option(“-F”,“–fft-size”,type=“int”,default=256,
help=“specify number of fft bins”)
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 the 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,
-20math.log10(self.fft_size)-10math.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)
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 set_next_freq(self):
target_freq = self.next_freq
self.next_freq = self.next_freq + self.freq_step
if self.next_freq >= self.max_center_freq:
self.next_freq = self.min_center_freq
if not self.set_freq(target_freq):
print "Failed to set frequency to", target_freq
sys.exit(1)
return target_freq
def set_freq(self,target_freq):
r=self.u.set_center_freq(target_freq)
if r:
return True
return False
def set_gain(self,gain):
self.u.set_gain(gain)
def main_loop(tb):
while 1:
#get the next message sent from the c++ code(blocking call)
#it contains the center frequency and the mag squared of the fft
m=parse_msg(tb.msgq.delete_head())
#print center freq so we know that something is happening
print m.center_freq
#print m.data
if name==‘main’:
t=ThreadClass()
t.start()
tb=my_top_block()
try:
tb.start()
main_loop(tb)
except KeyboardInterrupt:
pass
–
View this message in context:
http://gnuradio.4.n7.nabble.com/USRP-spectrum-sensing-tp51288.html
Sent from the GnuRadio mailing list archive at Nabble.com.
