[Discuss-gnuradio] USRP spectrum sensing

[Leo Yang]

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,
                          
-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)

        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.