Esempio n. 1
0
    def test_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 = blocks.vector_source_f(src_data, False)
        s2v = blocks.stream_to_vector(gr.sizeof_float, vlen)
        stats = blocks.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)
Esempio n. 2
0
    def test_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 = blocks.vector_source_f(src_data, False)
        s2v = blocks.stream_to_vector(gr.sizeof_float, vlen)
        stats = blocks.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)
Esempio n. 3
0
    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=0.25,
            metavar="SECS",
            help=
            "time to delay (in seconds) after changing frequency [default=%default]"
        )
        parser.add_option(
            "",
            "--dwell-delay",
            type="eng_float",
            default=0.25,
            metavar="SECS",
            help=
            "time to dwell (in seconds) at a given frequency [default=%default]"
        )
        parser.add_option(
            "-b",
            "--channel-bandwidth",
            type="eng_float",
            default=6.25e3,
            metavar="Hz",
            help="channel bandwidth of fft bins in Hz [default=%default]")
        parser.add_option("-l",
                          "--lo-offset",
                          type="eng_float",
                          default=0,
                          metavar="Hz",
                          help="lo_offset in Hz [default=%default]")
        parser.add_option("-q",
                          "--squelch-threshold",
                          type="eng_float",
                          default=None,
                          metavar="dB",
                          help="squelch threshold in dB [default=%default]")
        parser.add_option(
            "-F",
            "--fft-size",
            type="int",
            default=None,
            help="specify number of FFT bins [default=samp_rate/channel_bw]")
        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.channel_bandwidth = options.channel_bandwidth

        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

        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.u.set_samp_rate(options.samp_rate)
        self.usrp_rate = usrp_rate = self.u.get_samp_rate()

        self.lo_offset = options.lo_offset

        if options.fft_size is None:
            self.fft_size = int(self.usrp_rate / self.channel_bandwidth)
        else:
            self.fft_size = options.fft_size

        self.squelch_threshold = options.squelch_threshold

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)

        mywindow = filter.window.blackmanharris(self.fft_size)
        ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
        power = 0
        for tap in mywindow:
            power += tap * tap

        c2mag = blocks.complex_to_mag_squared(self.fft_size)

        # FIXME the log10 primitive is dog slow
        #log = blocks.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 = self.nearest_freq((0.75 * self.usrp_rate),
                                           self.channel_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.nstep = nsteps
        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)))  #调频延时转化为 FFT 计算时忽略的向量个数。 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(1)
        self._tune_callback = tune(
            self)  # hang on to this to keep it from being GC'd
        stats = blocks.bin_statistics_f(self.fft_size, self.msgq,
                                        self._tune_callback, tune_delay,
                                        dwell_delay)
        #mydata = open('mydata.log', mode = 'a+')
        print "usrp_rate=",self.usrp_rate,"channel_bandwidth(频谱分辨率)=",self.channel_bandwidth,\
          "fft_size= ",self.fft_size ,"freq_step(扫频长度)=", self.freq_step,"nsteps=",nsteps  #,"tune_delay=",tune_delay,"dwell_delay=",dwell_delay
        #mydata.close()

        # FIXME leave out the log10 until we speed it up
        #self.connect(self.u, s2v, ffter, c2mag, log, stats)
        self.connect(self.u, s2v, ffter, 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
Esempio n. 4
0
    def __init__(self):
        gr.top_block.__init__(self)

        usage = "usage: %prog [options] down_freq"
        parser = OptionParser(option_class=eng_option, usage=usage)
        parser.add_option("-a", "--args", type="string", default="addr=192.168.20.2",
                          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=0.25, metavar="SECS",
                          help="time to delay (in seconds) after changing frequency [default=%default]")
        parser.add_option("", "--dwell-delay", type="eng_float",
                          default=0.25, metavar="SECS",
                          help="time to dwell (in seconds) at a given frequency [default=%default]")
        parser.add_option("-b", "--channel-bandwidth", type="eng_float",
                          default=976.56, metavar="Hz",
                          help="channel bandwidth of fft bins in Hz [default=%default]")
        parser.add_option("-l", "--lo-offset", type="eng_float",
                          default=0, metavar="Hz",
                          help="lo_offset in Hz [default=%default]")
        parser.add_option("-q", "--squelch-threshold", type="eng_float",
                          default=None, metavar="dB",
                          help="squelch threshold in dB [default=%default]")
        parser.add_option("-F", "--fft-size", type="int", default=None,
                          help="specify number of FFT bins [default=samp_rate/channel_bw]")
        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) != 1:
            parser.print_help()
            sys.exit(1)

        self.channel_bandwidth = options.channel_bandwidth

        self.down_freq = eng_notation.str_to_num(args[0])
        self.up_freq = (self.down_freq) - 45e6



        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.u.set_samp_rate(options.samp_rate)

        self.usrp_rate = usrp_rate = self.u.get_samp_rate()
        
        self.lo_offset = options.lo_offset

        if options.fft_size is None:
            self.fft_size = int(self.usrp_rate/self.channel_bandwidth)
        else:
            self.fft_size = options.fft_size
        
        self.squelch_threshold = options.squelch_threshold
        
        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)

        mywindow = filter.window.blackmanharris(self.fft_size)
        ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
        power = 0
        for tap in mywindow:
            power += tap*tap

        c2mag = blocks.complex_to_mag_squared(self.fft_size)


        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(1)
        self._tune_callback = tune(self)        # hang on to this to keep it from being GC'd
        stats = blocks.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, ffter, c2mag, log, stats)
	self.connect(self.u, s2v, ffter, 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
Esempio n. 5
0
    def __init__(self, set_min_freq=False, set_max_freq=False):
        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='RX2',
                          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=0.05, metavar="SECS",#change default from
                          #.25 to .05 -GW
                          help="time to delay (in seconds) after changing frequency [default=%default]")
        parser.add_option("", "--dwell-delay", type="eng_float",
                          default=0.05, metavar="SECS",#changed default from
                          #.25 to .05 - GW
                          help="time to dwell (in seconds) at a given frequency [default=%default]")
        parser.add_option("-b", "--channel-bandwidth", type="eng_float",
                          default=6.25e3, metavar="Hz",
                          help="channel bandwidth of fft bins in Hz [default=%default]")
        parser.add_option("-l", "--lo-offset", type="eng_float",
                          default=0, metavar="Hz",
                          help="lo_offset in Hz [default=%default]")
        parser.add_option("-q", "--squelch-threshold", type="eng_float",
                          default=None, metavar="dB",
                          help="squelch threshold in dB [default=%default]")
        parser.add_option("-F", "--fft-size", type="int", default=None,
                          help="specify number of FFT bins [default=samp_rate/channel_bw]")
        parser.add_option("", "--real-time", action="store_true", default=False,
                          help="Attempt to enable real-time scheduling")
        parser.add_option("-G", "--gps", type='int', dest="gps_flag", default=0,
                          help="toggle gps recording : 1 or 0")
        parser.add_option("-r", "--rawstore", type='int',  dest="raw_store",
                          default=0,
                          help="store raw data from channel FFT bins : 1 or 0")
        parser.add_option("-S", "--spstore", type="int", default='0',
                      help="store signal properties in JSON format: 1 or 0")
        parser.add_option("-T", "--training", type="int", dest= "training_scan",
                          default='0',
                          help="set as training scan for data collection: 1 or 0")

        (options, args) = parser.parse_args()
        
        #modded : set freq  to directly passed frequencies for explicit call of class
        #from channel object. Can still use passed args direct from cmd line.GW
        
        if len(args) == 2:
            self.min_freq = eng_notation.str_to_num(args[0])
            self.max_freq = eng_notation.str_to_num(args[1])
        if len(args) !=2 and (not set_min_freq or not set_max_freq):
            parser.print_help()
            sys.exit(1)
        if set_min_freq and set_max_freq:
            self.min_freq = set_min_freq
            self.max_freq = set_max_freq

        self.channel_bandwidth = options.channel_bandwidth


        if self.min_freq > self.max_freq:
            # swap them
            self.min_freq, self.max_freq = self.max_freq, self.min_freq

        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.u.set_samp_rate(options.samp_rate)
        self.usrp_rate = usrp_rate = self.u.get_samp_rate()

        self.lo_offset = options.lo_offset

        if options.fft_size is None:
            self.fft_size = int(self.usrp_rate/self.channel_bandwidth)
        else:
            self.fft_size = options.fft_size

        self.squelch_threshold = options.squelch_threshold

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
        
        #creating DC blocker block to remove DC component - GW
        dc_blocker = filter.dc_blocker_cc(80, True)
	
        mywindow = filter.window.blackmanharris(self.fft_size)
        ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
        power = 0
        for tap in mywindow:
            power += tap*tap

        c2mag = blocks.complex_to_mag_squared(self.fft_size)

	# print c2mag

        # FIXME the log10 primitive is dog slow
        #log = blocks.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 = self.nearest_freq((0.75 * self.usrp_rate), self.channel_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 * 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(1)
        self._tune_callback = tune(self)        # hang on to this to keep it from being GC'd
        stats = blocks.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, ffter, c2mag, log, stats)
	self.connect(self.u, dc_blocker, s2v, ffter, 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
Esempio n. 6
0
    def __init__(self):
        gr.top_block.__init__(self)

        # usage = "usage: %prog [options] min_freq max_freq"
        usage = "usage: %prog [options] mycenter_freq show_band"

        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=0.25, metavar="SECS",
                          help="time to delay (in seconds) after changing frequency [default=%default]")
        parser.add_option("", "--dwell-delay", type="eng_float",
                          default=0.25, metavar="SECS",
                          help="time to dwell (in seconds) at a given frequency [default=%default]")
        # parser.add_option("-b", "--channel-bandwidth", type="eng_float",
        #                   default=6.25e3, metavar="Hz",
        #                   help="channel bandwidth of fft bins in Hz [default=%default]")#这个应该是频率分辨度(的而他f)
        parser.add_option("-l", "--lo-offset", type="eng_float",
                          default=0, metavar="Hz",
                          help="lo_offset in Hz [default=%default]")
        parser.add_option("-q", "--squelch-threshold", type="eng_float",
                          default=None, metavar="dB",
                          help="squelch threshold in dB [default=%default]")
        parser.add_option("-F", "--fft-size", type="int", default=None,
                          help="specify number of FFT bins [default=1024]")
        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.channel_bandwidth = options.channel_bandwidth

        myusrprate=options.samp_rate
        self.fft_size = options.fft_size
        self.channel_bandwidth = myusrprate/self.fft_size 

        self.mycenter_freq = eng_notation.str_to_num(args[0])
        self.show_band     = eng_notation.str_to_num(args[1])
        if self.show_band >myusrprate:
            sys.stderr.write("error:show_band must be smaller than samplerate\n")
            sys.exit(1)
        show_band=self.show_band 
        #add
        temp_varible=show_band/2
        self.min_freq = self.mycenter_freq - temp_varible
        self.max_freq = self.mycenter_freq + temp_varible

        args[0]=eng_notation.num_to_str(self.min_freq)
        args[1]=eng_notation.num_to_str(self.max_freq)

        # if self.min_freq > self.max_freq:
        #     # swap them
        #     self.min_freq, self.max_freq = self.max_freq, self.min_freq

        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应该是调用真实的usrp的信号self.u有地址和数据
        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.u.set_samp_rate(options.samp_rate)
        self.usrp_rate = usrp_rate = self.u.get_samp_rate()

        self.lo_offset = options.lo_offset

        self.squelch_threshold = options.squelch_threshold

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)#stream_to_vector

        mywindow = filter.window.blackmanharris(self.fft_size)
        ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)#滤波参数
        power = 0
        for tap in mywindow:
            power += tap*tap

        c2mag = blocks.complex_to_mag_squared(self.fft_size)#平方运算

        # FIXME the log10 primitive is dog slow
        #log = blocks.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 = self.nearest_freq(show_band, self.channel_bandwidth)#频率分辨率的整数倍(并不等于自己设置的那个),也是扫频长度
        self.center_freq = self.min_freq + (self.freq_step/2)#算最小中心频率
        # nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
        # self.center_freq = self.min_center_freq + self.freq_step

        self.next_freq = self.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(1)
        self._tune_callback = tune(self)        # 是USRP调谐频率过程的一个程序句柄,有了它,stats就可以调用调谐子程序了hang on to this to keep it from being GC'd
        stats = blocks.bin_statistics_f(self.fft_size, self.msgq,
                                        self._tune_callback, tune_delay,#等待时间,扫频时间等可能都在这个函数中实现
                                        dwell_delay)      #构建一个bin统计数据块(可能是计算出下一个的中心频率)
        print "usrp_rate=",self.usrp_rate,"channel_bandwidth(频谱分辨率)=",self.channel_bandwidth,\
             "fft_size= ",self.fft_size ,"freq_step(扫频长度)=", self.freq_step
        # FIXME leave out the log10 until we speed it up

	#self.connect(self.u, s2v, ffter, c2mag, log, stats)
	self.connect(self.u, s2v, ffter, 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)

        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=20e-3,
            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=2048,
                          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")
        parser.add_option("-d",
                          "--decim",
                          type="intx",
                          default=4,
                          help="set decimation to DECIM [default=%default]")

        (options, args) = parser.parse_args()
        if len(args) != 2:
            parser.print_help()
            sys.exit(1)

        Freq = Value('i', 9475 * 10**5)
        self.min_freq = Freq.value - (
            10 * 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 + (10 * 10**6)

        if self.min_freq > self.max_freq:
            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:
            r = gr.enable_realtime_scheduling()
            if r == gr.RT_OK:
                realtime = True
            else:
                realtime = False
                print "Note: failed to enable realtime scheduling"

        self.u = uhd.usrp_source(device_addr=options.args,
                                 stream_args=uhd.stream_args('fc32'))

        if (options.spec):
            self.u.set_subdev_spec(options.spec, 0)
        if (options.antenna):
            self.u.set_antenna(options.antenna, 0)

        global size
        size = self.fft_size

        global samp_rate
        samp_rate = 100e6 / options.decim
        self.u.set_samp_rate(samp_rate)

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
        mywindow = fft.window.blackmanharris(self.fft_size)
        fftvar = fft.fft_vcc(self.fft_size, True, mywindow)

        power = 0
        for tap in mywindow:
            power += tap * tap
        c2mag = blocks.complex_to_mag_squared(self.fft_size)
        log = blocks.nlog10_ff(
            10, self.fft_size, -20 * math.log10(self.fft_size) -
            10 * math.log10(power / self.fft_size))

        self.freq_step = 0  #0.75 * usrp_rate		# Modified
        self.min_center_freq = (self.min_freq + self.max_freq) / 2
        nsteps = 100  #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)
        self._tune_callback = tune(
            self)  # hang on to this to keep it from being GC'd
        stats = blocks.bin_statistics_f(self.fft_size, self.msgq,
                                        self._tune_callback, tune_delay,
                                        dwell_delay)

        self.connect(self.u, s2v, fftvar, c2mag, stats)

        if options.gain is None:
            g = self.u.get_gain_range()
            options.gain = float(g.start() + g.stop()) / 2.0
Esempio n. 8
0
    def __init__(self):
        gr.top_block.__init__(self)

        usage = "usage: %prog [options] down_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=10e6,
                          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=0.25,
            metavar="SECS",
            help=
            "time to delay (in seconds) after changing frequency [default=%default]"
        )
        parser.add_option(
            "",
            "--dwell-delay",
            type="eng_float",
            default=0.25,
            metavar="SECS",
            help=
            "time to dwell (in seconds) at a given frequency [default=%default]"
        )
        parser.add_option(
            "-b",
            "--channel-bandwidth",
            type="eng_float",
            default=9.7656e3,
            metavar="Hz",
            help="channel bandwidth of fft bins in Hz [default=%default]")
        parser.add_option("-l",
                          "--lo-offset",
                          type="eng_float",
                          default=0,
                          metavar="Hz",
                          help="lo_offset in Hz [default=%default]")
        parser.add_option("-q",
                          "--squelch-threshold",
                          type="eng_float",
                          default=None,
                          metavar="dB",
                          help="squelch threshold in dB [default=%default]")
        parser.add_option(
            "-F",
            "--fft-size",
            type="int",
            default=None,
            help="specify number of FFT bins [default=samp_rate/channel_bw]")
        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) != 1:
            parser.print_help()
            sys.exit(1)

        self.channel_bandwidth = options.channel_bandwidth

        self.down_freq = eng_notation.str_to_num(args[0])
        self.up_freq = self.down_freq - 45e6

        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.u.set_samp_rate(options.samp_rate)

        self.usrp_rate = usrp_rate = self.u.get_samp_rate()

        self.lo_offset = options.lo_offset

        if options.fft_size is None:
            self.fft_size = int(self.usrp_rate / self.channel_bandwidth)
        else:
            self.fft_size = options.fft_size

        self.squelch_threshold = options.squelch_threshold

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)

        mywindow = filter.window.blackmanharris(self.fft_size)
        ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
        power = 0
        for tap in mywindow:
            power += tap * tap

        c2mag = blocks.complex_to_mag_squared(self.fft_size)

        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(1)
        self._tune_callback = tune(
            self)  # hang on to this to keep it from being GC'd
        stats = blocks.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, ffter, c2mag, log, stats)
        self.connect(self.u, s2v, ffter, 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
Esempio n. 9
0
    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="addr=192.168.10.2",
                          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="TX/RX",
                          help="select Rx Antenna where appropriate [default=%default]")
        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("-i", "--ip", type="string", default='192.168.10.1',
                          help="ip address of server [default=%default]")
	parser.add_option("-p", "--port", type="int", default=9001,
                          help="port for network connection [default=%default]")
        parser.add_option("", "--tune-delay", type="eng_float",
                          default=0.25, metavar="SECS",
                          help="time to delay (in seconds) after changing frequency [default=%default]")
        parser.add_option("", "--dwell-delay", type="eng_float",
                          default=0.25, metavar="SECS",
                          help="time to dwell (in seconds) at a given frequency [default=%default]")
        parser.add_option("-b", "--channel-bandwidth", type="eng_float",
                          default=6.25e3, metavar="Hz",
                          help="channel bandwidth of fft bins in Hz [default=%default]")
        parser.add_option("-l", "--lo-offset", type="eng_float",
                          default=0, metavar="Hz",
                          help="lo_offset in Hz [default=%default]")
        parser.add_option("-q", "--squelch-threshold", type="eng_float",
                          default=None, metavar="dB",
                          help="squelch threshold in dB [default=%default]")
        parser.add_option("-F", "--fft-size", type="int", default=None,
                          help="specify number of FFT bins [default=samp_rate/channel_bw]")
        parser.add_option("", "--real-time", action="store_true", default=False,
                          help="Attempt to enable real-time scheduling")

	#Parse options
        (options, args) = parser.parse_args()
        if len(args) != 2:
            parser.print_help()
	    min_fbound = '400e6'
	    max_fbound = '4.4e9'
	else:
	    max_fbound = args[1]
	    min_fbound = args[0]
	
        self.channel_bandwidth = options.channel_bandwidth

        #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

        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"

        # USRP SOURCE CONFIG
        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.u.set_samp_rate(options.samp_rate)
        self.usrp_rate = usrp_rate = self.u.get_samp_rate()

	#FFT CONFIG
        self.lo_offset = options.lo_offset

        if options.fft_size is None:
            self.fft_size = int(self.usrp_rate/self.channel_bandwidth)
        else:
            self.fft_size = options.fft_size

        self.squelch_threshold = options.squelch_threshold
	
	self.freq_step = self.nearest_freq((0.75 * self.usrp_rate), self.channel_bandwidth)
	
	self.set_fbounds(max_fbound, min_fbound)

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
	
        mywindow = filter.window.blackmanharris(self.fft_size)
        ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
        power = 0
        for tap in mywindow:
            power += tap*tap
	
	#COMPLEX TO MAG CONFIG
        c2mag = blocks.complex_to_mag_squared(self.fft_size)

        # FIXME the log10 primitive is dog slow
        #log = blocks.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.

        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
	
	#BIN_STATISTICS CONFIG
        self.msgq = gr.msg_queue(1)
        self._tune_callback = tune(self)        # hang on to this to keep it from being GC'd
        stats = blocks.bin_statistics_f(self.fft_size, self.msgq,
                                        self._tune_callback, tune_delay,
                                        dwell_delay)

	#IP CORE CONFIG
	self.ip = options.ip
	self.port = options.port
	self.s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
	
	self.s.bind(("",self.port))
	#self.s.listen(1)
	print "Waiting for connection at", self.ip, "using port", self.port
	
	data, self.connAdd = self.s.recvfrom(self.port)
	self.s.sendto("Ack", self.connAdd)
	print "Connection recieved from", self.connAdd
	
	#CONNECT ALL THE THINGS
        # FIXME leave out the log10 until we speed it up
	#self.connect(self.u, s2v, ffter, c2mag, log, stats)
	self.connect(self.u, s2v, ffter, c2mag, stats)

	#Do gain things
        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)
Esempio n. 10
0
    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 address args [default=%default]")
        parser.add_option("",
                          "--spec",
                          type="string",
                          default=None,
                          help="Subdevice of UHD device where appropriate")
        parser.add_option("-R",
                          "--rx-antenna",
                          type="string",
                          default="RX2",
                          help="select RX antenna where appropriate")
        parser.add_option("-T",
                          "--tx-antenna",
                          type="string",
                          default="TX/RX",
                          help="select TX 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=0.25,
            metavar="SECS",
            help=
            "time to delay (in seconds) after changing frequency [default=%default]"
        )
        parser.add_option(
            "",
            "--dwell-delay",
            type="eng_float",
            default=0.25,
            metavar="SECS",
            help=
            "time to delay (in seconds) at a given frequency [default=%default]"
        )
        parser.add_option(
            "-b",
            "--channel-bandwidth",
            type="eng_float",
            default=6.25e3,
            metavar="Hz",
            help="channel bandwidth of fft bins in Hz [default=%default]")
        parser.add_option("-l",
                          "--lo-offset",
                          type="eng_float",
                          default=0,
                          metavar="Hz",
                          help="lo_offset in Hz [default=%default]")
        parser.add_option("-q",
                          "--squelch-threshold",
                          type="eng_float",
                          default=None,
                          metavar="dB",
                          help="squelch threshold in dB [default=%default]")
        parser.add_option(
            "-F",
            "--fft-size",
            type="int",
            default=None,
            help="specify the number of FFT bins [default=samp_rate/channel_bw]"
        )
        parser.add_option("",
                          "--real-time",
                          action="store_true",
                          default=False,
                          help="Attempt to enable real-time scheduling")
        parser.add_option(
            "-w",
            "--tx-bandwidth",
            type="eng_float",
            default=6e6,
            metavar="Hz",
            help="transmit frequency bandwidth [default=%default]")

        (options, args) = parser.parse_args()
        if len(args) != 2:
            parser.print_help()
            sys.exit(1)

        self.channel_bandwidth = options.channel_bandwidth  #fft channel bandwidth
        self.tx_bandwidth = options.tx_bandwidth

        self.min_freq = eng_notation.str_to_num(args[0])
        self.max_freq = eng_notation.str_to_num(args[1])

        if self.min_freq < 1e6: self.min_freq *= 1e6
        if self.max_freq < 1e6: self.max_freq *= 1e6

        self.n_channel_grps = 5  #number of channel groups
        self.curr_channel_grp = 0
        self.n_channels = 5  #number of channels / channel group
        self.curr_channel = 0

        self.tx_guard_band = 4e6

        if self.min_freq > self.max_freq:
            #swap them
            self.min_freq, self.max_freq = self.max_freq, self.min_freq

        self.channel_grp_bw = (self.max_freq -
                               self.min_freq) / self.n_channel_grps
        self.tx_channel_bw = self.channel_grp_bw / self.n_channels  # tx channel bw

        if not options.real_time:
            real_time = 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_rx = uhd.usrp_source(device_addr=options.args,
                                    stream_args=uhd.stream_args('fc32'))

        #Set the subdevice spec
        if options.spec:
            self.u_rx.set_subdev_spec(options.spec, 0)

        #Set the antenna
        if options.rx_antenna:
            self.u_rx.set_antenna(options.rx_antenna, 0)

        self.u_rx.set_samp_rate(options.samp_rate)
        self.usrp_rate = usrp_rate = self.u_rx.get_samp_rate()

        self.lo_offset = options.lo_offset

        if options.fft_size is None:
            self.fft_size = int(self.usrp_rate / self.channel_bandwidth)
        else:
            self.fft_size = options.fft_size

        print "FFT Size: %d, USRP Samp Rate: %d, Channel Bandwidth: %d" % (
            self.fft_size, self.usrp_rate, self.channel_bandwidth)

        self.squelch_threshold = options.squelch_threshold

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)

        mywindow = filter.window.blackmanharris(self.fft_size)
        ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)

        c2mag = blocks.complex_to_mag_squared(self.fft_size)

        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(1)
        self._tune_callback = tune(
            self)  #hang on to this to keep it from being GC'd

        stats = blocks.bin_statistics_f(self.fft_size, self.msgq,
                                        self._tune_callback, tune_delay,
                                        dwell_delay)

        self.connect(self.u_rx, s2v, ffter, c2mag, stats)

        #transmit chain

        d = uhd.find_devices(uhd.device_addr(options.args))
        if d:

            uhd_type = d[0].get('type')
            print "\nFound '%s'" % uhd_type
        else:
            print "\nNo device found"
            self.u_tx = None
            return

        #check version of USRP and set num_channels

        if uhd_type == "usrp":
            tx_nchan = 2
            rx_nchan = 2
        else:
            tx_nchan = 1
            rx_nchan = 1

        #setup transmit chain (usrp sink, signal source)

        #usrp sink
        stream_args = uhd.stream_args('fc32', channels=range(tx_nchan))
        self.u_tx = uhd.usrp_sink(device_addr=options.args,
                                  stream_args=stream_args)
        self.u_tx.set_samp_rate(self.usrp_rate)

        if options.tx_antenna:
            self.u_tx.set_antenna(options.tx_antenna, 0)

#analog signal source - sig_source_c(sampling_freq,waveform, wave_freq, ampl, offset=0)
        self.tx_src0 = analog.sig_source_c(self.u_tx.get_samp_rate(),
                                           analog.GR_CONST_WAVE, 0, 1.0, 0)

        #connect blocks

        self.connect(self.tx_src0, self.u_tx)

        if options.gain is None:
            # if no gain was specified use the midpoint in dB
            g = self.u_rx.get_gain_range()
            options.gain = float(g.start() + g.stop()) / 2.0

        self.set_gain(options.gain)
        print "gain =", options.gain

        #initialize transmission parameters
        self.set_channel_group(3)
        self.step_count = 0
    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=20e-3, 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=2048 , 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")
        parser.add_option("-d", "--decim", type="intx", default=4, help="set decimation to DECIM [default=%default]")

        (options, args) = parser.parse_args()
        if len(args) != 2:
            parser.print_help()
            sys.exit(1)
            
        Freq=Value('i',9475*10**5)    
	self.min_freq = Freq.value-(10*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+(10*10**6)
        
        if self.min_freq > self.max_freq:
            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:
            r = gr.enable_realtime_scheduling()
            if r == gr.RT_OK:
                realtime = True
            else:
                realtime = False
                print "Note: failed to enable realtime scheduling"

        self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
        
        if(options.spec):
            self.u.set_subdev_spec(options.spec, 0)
        if(options.antenna):
            self.u.set_antenna(options.antenna, 0)
            
	global size
	size=self.fft_size
	
        global samp_rate
        samp_rate = 100e6/options.decim
        self.u.set_samp_rate(samp_rate)
	    
	s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
        mywindow = fft.window.blackmanharris(self.fft_size)
        fftvar = fft.fft_vcc(self.fft_size, True, mywindow)
        
        power = 0
        for tap in mywindow:
            power += tap*tap
        c2mag = blocks.complex_to_mag_squared(self.fft_size)
        log = blocks.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))

        self.freq_step = 0 #0.75 * usrp_rate		# Modified
        self.min_center_freq = (self.min_freq + self.max_freq)/2
        nsteps = 100 #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)
        self._tune_callback = tune(self)        # hang on to this to keep it from being GC'd
        stats = blocks.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay)

	self.connect(self.u, s2v, fftvar, c2mag, stats)

        if options.gain is None:
            g = self.u.get_gain_range()
            options.gain = float(g.start()+g.stop())/2.0
Esempio n. 12
0
    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="addr=192.168.10.2",
            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="TX/RX",
            help="select Rx Antenna where appropriate [default=%default]")
        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("-i",
                          "--ip",
                          type="string",
                          default='192.168.10.1',
                          help="ip address of server [default=%default]")
        parser.add_option(
            "-p",
            "--port",
            type="int",
            default=9001,
            help="port for network connection [default=%default]")
        parser.add_option(
            "",
            "--tune-delay",
            type="eng_float",
            default=0.25,
            metavar="SECS",
            help=
            "time to delay (in seconds) after changing frequency [default=%default]"
        )
        parser.add_option(
            "",
            "--dwell-delay",
            type="eng_float",
            default=0.25,
            metavar="SECS",
            help=
            "time to dwell (in seconds) at a given frequency [default=%default]"
        )
        parser.add_option(
            "-b",
            "--channel-bandwidth",
            type="eng_float",
            default=6.25e3,
            metavar="Hz",
            help="channel bandwidth of fft bins in Hz [default=%default]")
        parser.add_option("-l",
                          "--lo-offset",
                          type="eng_float",
                          default=0,
                          metavar="Hz",
                          help="lo_offset in Hz [default=%default]")
        parser.add_option("-q",
                          "--squelch-threshold",
                          type="eng_float",
                          default=None,
                          metavar="dB",
                          help="squelch threshold in dB [default=%default]")
        parser.add_option(
            "-F",
            "--fft-size",
            type="int",
            default=None,
            help="specify number of FFT bins [default=samp_rate/channel_bw]")
        parser.add_option("",
                          "--real-time",
                          action="store_true",
                          default=False,
                          help="Attempt to enable real-time scheduling")

        #Parse options
        (options, args) = parser.parse_args()
        if len(args) != 2:
            parser.print_help()
            min_fbound = '400e6'
            max_fbound = '4.4e9'
        else:
            max_fbound = args[1]
            min_fbound = args[0]

        self.channel_bandwidth = options.channel_bandwidth

        #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

        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"

        # USRP SOURCE CONFIG
        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.u.set_samp_rate(options.samp_rate)
        self.usrp_rate = usrp_rate = self.u.get_samp_rate()

        #FFT CONFIG
        self.lo_offset = options.lo_offset

        if options.fft_size is None:
            self.fft_size = int(self.usrp_rate / self.channel_bandwidth)
        else:
            self.fft_size = options.fft_size

        self.squelch_threshold = options.squelch_threshold

        self.freq_step = self.nearest_freq((0.75 * self.usrp_rate),
                                           self.channel_bandwidth)

        self.set_fbounds(max_fbound, min_fbound)

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)

        mywindow = filter.window.blackmanharris(self.fft_size)
        ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
        power = 0
        for tap in mywindow:
            power += tap * tap

#COMPLEX TO MAG CONFIG
        c2mag = blocks.complex_to_mag_squared(self.fft_size)

        # FIXME the log10 primitive is dog slow
        #log = blocks.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.

        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

        #BIN_STATISTICS CONFIG
        self.msgq = gr.msg_queue(1)
        self._tune_callback = tune(
            self)  # hang on to this to keep it from being GC'd
        stats = blocks.bin_statistics_f(self.fft_size, self.msgq,
                                        self._tune_callback, tune_delay,
                                        dwell_delay)

        #IP CORE CONFIG
        self.ip = options.ip
        self.port = options.port
        self.s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        self.s.bind(("", self.port))
        #self.s.listen(1)
        print "Waiting for connection at", self.ip, "using port", self.port

        data, self.connAdd = self.s.recvfrom(self.port)
        self.s.sendto("Ack", self.connAdd)
        print "Connection recieved from", self.connAdd

        #CONNECT ALL THE THINGS
        # FIXME leave out the log10 until we speed it up
        #self.connect(self.u, s2v, ffter, c2mag, log, stats)
        self.connect(self.u, s2v, ffter, c2mag, stats)

        #Do gain things
        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)
Esempio n. 13
0
    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="Device args [default=%default]")
        parser.add_option("-A", "--antenna", type="string", default=None,
                          help="Select antenna where appropriate")
        parser.add_option("-s", "--samp-rate", type="eng_float", default=None,
                          help="Set sample rate (bandwidth), minimum by 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=0.25, metavar="SECS",
                          help="Time to delay (in seconds) after changing frequency [default=%default]")
        parser.add_option("", "--dwell-delay", type="eng_float",
                          default=0.25, metavar="SECS",
                          help="Time to dwell (in seconds) at a given frequency [default=%default]")
        parser.add_option("-b", "--channel-bandwidth", type="eng_float",
                          default=6.25e3, metavar="Hz",
                          help="Channel bandwidth of fft bins in Hz [default=%default]")
        parser.add_option("-q", "--squelch-threshold", type="eng_float",
                          default=None, metavar="dB",
                          help="Squelch threshold in dB [default=%default]")
        parser.add_option("-F", "--fft-size", type="int", default=None,
                          help="Specify number of FFT bins [default=samp_rate/channel_bw]")
        parser.add_option("", "--real-time", action="store_true", default=False,
                          help="Attempt to enable real-time scheduling")
        parser.add_option("-m", "--amp-multiply",type="eng_float",default=25.5,
                          help="Specify amplitude multiplier")

        (options, args) = parser.parse_args()
        if len(args) != 2:
            parser.print_help()
            sys.exit(1)

        self.channel_bandwidth = options.channel_bandwidth

        self.min_freq = eng_notation.str_to_num(args[0])
        self.max_freq = eng_notation.str_to_num(args[1])

        try:
            if options.amp_multiply > 1 or options.amp_multiply <255:
                self.amp_multiply = options.amp_multiply
        except:
            print 'amplification multiplier not valid'


        if self.min_freq > self.max_freq:
            # swap them
            self.min_freq, self.max_freq = self.max_freq, self.min_freq

        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 = osmosdr.source(options.args)

        try:
            self.u.get_sample_rates().start()
        except RuntimeError:
            print "Source has no sample rates (wrong device arguments?)."
            sys.exit(1)

        # Set the antenna
        if(options.antenna):
            self.u.set_antenna(options.antenna, 0)

        if options.samp_rate is None:
            options.samp_rate = self.u.get_sample_rates().start()

        self.u.set_sample_rate(options.samp_rate)
        self.usrp_rate = usrp_rate = self.u.get_sample_rate()

        if options.fft_size is None:
            self.fft_size = int(self.usrp_rate/self.channel_bandwidth)
        else:
            self.fft_size = options.fft_size

        self.squelch_threshold = options.squelch_threshold

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)

        mywindow = filter.window.blackmanharris(self.fft_size)
        ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
        power = 0
        for tap in mywindow:
            power += tap*tap

        c2mag = blocks.complex_to_mag_squared(self.fft_size)

        # FIXME the log10 primitive is dog slow
        #log = blocks.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 = self.nearest_freq((0.75 * self.usrp_rate), self.channel_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 * 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(1)
        self._tune_callback = tune(self)        # hang on to this to keep it from being GC'd
        stats = blocks.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, ffter, c2mag, log, stats)
        self.connect(self.u, s2v, ffter, 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
Esempio n. 14
0
    def __init__(self, parser):
        gr.top_block.__init__(self)

        (options, args) = parser.parse_args()

        self.channel_bandwidth = options.channel_bandwidth

        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

        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.u.set_samp_rate(options.samp_rate)
        self.usrp_rate = usrp_rate = self.u.get_samp_rate()

        self.lo_offset = options.lo_offset

        if options.fft_size is None:
            self.fft_size = int(self.usrp_rate / self.channel_bandwidth)
        else:
            self.fft_size = options.fft_size

        self.squelch_threshold = options.squelch_threshold

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)

        mywindow = filter.window.blackmanharris(self.fft_size)
        ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
        power = 0
        for tap in mywindow:
            power += tap * tap

        c2mag = blocks.complex_to_mag_squared(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 = self.nearest_freq((0.75 * self.usrp_rate),
                                           self.channel_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 * 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(1)
        self._tune_callback = tune(self)
        stats = blocks.bin_statistics_f(self.fft_size, self.msgq,
                                        self._tune_callback, tune_delay,
                                        dwell_delay)

        self.connect(self.u, s2v, ffter, 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