Пример #1
0
    def __init__(self, frame, panel, vbox, argv):
        stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)

        self.frame = frame
        self.panel = panel

        parser = OptionParser(option_class=eng_option)
        parser.add_option("-a",
                          "--address",
                          type="string",
                          default="type=xmini",
                          help="Address of SHD device, [default=%default]")
        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 (bandwidth) [default=%default]")
        parser.add_option("-f",
                          "--freq",
                          type="eng_float",
                          default=None,
                          help="set frequency to FREQ",
                          metavar="FREQ")
        parser.add_option("-g",
                          "--gain",
                          type="eng_float",
                          default=None,
                          help="set gain in dB (default is midpoint)")
        parser.add_option("-W",
                          "--waterfall",
                          action="store_true",
                          default=False,
                          help="Enable waterfall display")
        parser.add_option("-S",
                          "--oscilloscope",
                          action="store_true",
                          default=False,
                          help="Enable oscilloscope display")
        parser.add_option(
            "",
            "--avg-alpha",
            type="eng_float",
            default=1e-1,
            help="Set fftsink averaging factor, default=[%default]")
        parser.add_option("",
                          "--ref-scale",
                          type="eng_float",
                          default=1.0,
                          help="Set dBFS=0dB input value, default=[%default]")
        parser.add_option("--fft-size",
                          type="int",
                          default=1024,
                          help="Set number of FFT bins [default=%default]")
        (options, args) = parser.parse_args()
        if len(args) != 0:
            parser.print_help()
            sys.exit(1)
        self.options = options
        self.show_debug_info = True

        self.src = shd.smini_source(device_addr=options.address,
                                    io_type=shd.io_type.COMPLEX_FLOAT32,
                                    num_channels=1)

        self.src.set_samp_rate(options.samp_rate)
        input_rate = self.src.get_samp_rate()

        if options.waterfall:
            self.scope = \
              waterfallsink2.waterfall_sink_c (panel, fft_size=1024,
                                               sample_rate=input_rate)
            self.frame.SetMinSize((800, 420))
        elif options.oscilloscope:
            self.scope = scopesink2.scope_sink_c(panel, sample_rate=input_rate)
            self.frame.SetMinSize((800, 600))
        else:
            self.scope = fftsink2.fft_sink_c(panel,
                                             fft_size=options.fft_size,
                                             sample_rate=input_rate,
                                             ref_scale=options.ref_scale,
                                             ref_level=20.0,
                                             y_divs=12,
                                             avg_alpha=options.avg_alpha)
            self.frame.SetMinSize((800, 420))

        self.connect(self.src, self.scope)

        self._build_gui(vbox)
        self._setup_events()

        # set initial values

        if options.gain is None:
            # if no gain was specified, use the mid-point in dB
            g = self.src.get_gain_range()
            options.gain = float(g.start() + g.stop()) / 2

        if options.freq is None:
            # if no freq was specified, use the mid-point
            r = self.src.get_freq_range()
            options.freq = float(r.start() + r.stop()) / 2

        self.set_gain(options.gain)

        if (options.antenna):
            self.src.set_antenna(options.antenna, 0)

        if self.show_debug_info:
            self.myform['samprate'].set_value(self.src.get_samp_rate())
            self.myform['fs@gbe'].set_value(input_rate)
            self.myform['baseband'].set_value(0)
            self.myform['ddc'].set_value(0)

        if not (self.set_freq(options.freq)):
            self._set_status_msg("Failed to set initial frequency")

        print "Center Freq: ", self.src.get_center_freq()
        print "Freq Range:  ", self.src.get_freq_range()
        print "Gain:        ", self.src.get_gain()
        print "Gain Names:  ", self.src.get_gain_names()
        print "Gain Range:  ", self.src.get_gain_range()
Пример #2
0
    def __init__(self, options, filename):
        gr.top_block.__init__(self)

        # Create a SHD device source
        if options.output_shorts:
            self._src = shd.smini_source(device_addr=options.address,
                                         io_type=shd.io_type.COMPLEX_INT16,
                                         num_channels=1)
            self._sink = gr.file_sink(gr.sizeof_short * 2, filename)
        else:
            self._src = shd.smini_source(device_addr=options.address,
                                         io_type=shd.io_type.COMPLEX_FLOAT32,
                                         num_channels=1)
            self._sink = gr.file_sink(gr.sizeof_gr_complex, filename)

        # Set receiver sample rate
        self._src.set_samp_rate(options.samp_rate)

        # Set receive daughterboard gain
        if options.gain is None:
            g = self._src.get_gain_range()
            options.gain = float(g.start() + g.stop()) / 2
            print "Using mid-point gain of", \
                       options.gain, "(", g.start(), "-", g.stop(), ")"
        self._src.set_gain(options.gain)

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

        # Set frequency (tune request takes lo_offset)
        if (options.lo_offset is not None):
            treq = shd.tune_request(options.freq, options.lo_offset)
        else:
            treq = shd.tune_request(options.freq)
        tr = self._src.set_center_freq(treq)
        if tr == None:
            sys.stderr.write('Failed to set center frequency\n')
            raise SystemExit, 1

        # Create head block if needed and wire it up
        if options.nsamples is None:
            self.connect(self._src, self._sink)
        else:
            if options.output_shorts:
                self._head = gr.head(gr.sizeof_short * 2,
                                     int(options.nsamples))
            else:
                self._head = gr.head(gr.sizeof_gr_complex,
                                     int(options.nsamples))

            self.connect(self._src, self._head, self._sink)

        input_rate = self._src.get_samp_rate()

        if options.verbose:
            print "Address:", options.address
            print "Rx gain:", options.gain
            print "Rx baseband frequency:", n2s(tr.actual_rf_freq)
            print "Rx DDC frequency:", n2s(tr.actual_dsp_freq)
            print "Rx Sample Rate:", n2s(input_rate)
            if options.nsamples is None:
                print "Receiving samples until Ctrl-C"
            else:
                print "Receving", n2s(options.nsamples), "samples"
            if options.output_shorts:
                print "Writing 16-bit complex shorts"
            else:
                print "Writing 32-bit complex floats"
            print "Output filename:", filename
Пример #3
0
    def __init__(self, frame, panel, vbox, argv):
        stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)

        self.frame = frame
        self.panel = panel
        
        parser = OptionParser(option_class=eng_option)
        parser.add_option("-a", "--address", type="string",
                          default="type=xmini",
                          help="Address of SHD device, [default=%default]")
        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 (bandwidth) [default=%default]")
        parser.add_option("-f", "--freq", type="eng_float", default=None,
                          help="set frequency to FREQ", metavar="FREQ")
        parser.add_option("-g", "--gain", type="eng_float", default=None,
                          help="set gain in dB (default is midpoint)")
        parser.add_option("-W", "--waterfall", action="store_true", default=False,
                          help="Enable waterfall display")
        parser.add_option("-S", "--oscilloscope", action="store_true", default=False,
                          help="Enable oscilloscope display")
	parser.add_option("", "--avg-alpha", type="eng_float", default=1e-1,
			  help="Set fftsink averaging factor, default=[%default]")
	parser.add_option("", "--ref-scale", type="eng_float", default=1.0,
			  help="Set dBFS=0dB input value, default=[%default]")
        parser.add_option("--fft-size", type="int", default=1024,
                          help="Set number of FFT bins [default=%default]")
        (options, args) = parser.parse_args()
        if len(args) != 0:
            parser.print_help()
            sys.exit(1)
	self.options = options
        self.show_debug_info = True
        
        self.src = shd.smini_source(device_addr=options.address,
                                    io_type=shd.io_type.COMPLEX_FLOAT32,
                                    num_channels=1)

        self.src.set_samp_rate(options.samp_rate)
        input_rate = self.src.get_samp_rate()

        if options.waterfall:
            self.scope = \
              waterfallsink2.waterfall_sink_c (panel, fft_size=1024,
                                               sample_rate=input_rate)
            self.frame.SetMinSize((800, 420))
        elif options.oscilloscope:
            self.scope = scopesink2.scope_sink_c(panel, sample_rate=input_rate)
            self.frame.SetMinSize((800, 600))
        else:
            self.scope = fftsink2.fft_sink_c (panel,
                                              fft_size=options.fft_size,
                                              sample_rate=input_rate, 
					      ref_scale=options.ref_scale,
                                              ref_level=20.0,
                                              y_divs = 12,
					      avg_alpha=options.avg_alpha)
            self.frame.SetMinSize((800, 420))

        self.connect(self.src, self.scope)

        self._build_gui(vbox)
	self._setup_events()

	
        # set initial values

        if options.gain is None:
            # if no gain was specified, use the mid-point in dB
            g = self.src.get_gain_range()
            options.gain = float(g.start()+g.stop())/2

        if options.freq is None:
            # if no freq was specified, use the mid-point
            r = self.src.get_freq_range()
            options.freq = float(r.start()+r.stop())/2
            
        self.set_gain(options.gain)

        if(options.antenna):
            self.src.set_antenna(options.antenna, 0)

        if self.show_debug_info:
            self.myform['samprate'].set_value(self.src.get_samp_rate())
            self.myform['fs@gbe'].set_value(input_rate)
            self.myform['baseband'].set_value(0)
            self.myform['ddc'].set_value(0)

        if not(self.set_freq(options.freq)):
            self._set_status_msg("Failed to set initial frequency")

        print "Center Freq: ", self.src.get_center_freq()
        print "Freq Range:  ", self.src.get_freq_range()
        print "Gain:        ", self.src.get_gain()
        print "Gain Names:  ", self.src.get_gain_names()
        print "Gain Range:  ", self.src.get_gain_range()
Пример #4
0
    def __init__(self, options, filename):
        gr.top_block.__init__(self)

        # Create a SHD device source
        if options.output_shorts:
            self._src = shd.smini_source(device_addr=options.address,
                                       io_type=shd.io_type.COMPLEX_INT16,
                                       num_channels=1)
            self._sink = gr.file_sink(gr.sizeof_short*2, filename)
        else:
            self._src = shd.smini_source(device_addr=options.address,
                                       io_type=shd.io_type.COMPLEX_FLOAT32,
                                       num_channels=1)
            self._sink = gr.file_sink(gr.sizeof_gr_complex, filename)
            
        # Set receiver sample rate
        self._src.set_samp_rate(options.samp_rate)

        # Set receive daughterboard gain
        if options.gain is None:
            g = self._src.get_gain_range()
            options.gain = float(g.start()+g.stop())/2
	    print "Using mid-point gain of", \
                options.gain, "(", g.start(), "-", g.stop(), ")"
        self._src.set_gain(options.gain)

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

        # Set frequency (tune request takes lo_offset)
        if(options.lo_offset is not None):
            treq = shd.tune_request(options.freq, options.lo_offset)
        else:
            treq = shd.tune_request(options.freq)
        tr = self._src.set_center_freq(treq)
        if tr == None:
            sys.stderr.write('Failed to set center frequency\n')
            raise SystemExit, 1

        # Create head block if needed and wire it up
        if options.nsamples is None:
            self.connect(self._src, self._sink)
        else:
            if options.output_shorts:
                self._head = gr.head(gr.sizeof_short*2,
                                     int(options.nsamples))
            else:
                self._head = gr.head(gr.sizeof_gr_complex,
                                     int(options.nsamples))

            self.connect(self._src, self._head, self._sink)

        input_rate = self._src.get_samp_rate()
        
        if options.verbose:
            print "Address:", options.address
            print "Rx gain:", options.gain
            print "Rx baseband frequency:", n2s(tr.actual_rf_freq)
            print "Rx DDC frequency:", n2s(tr.actual_dsp_freq)
            print "Rx Sample Rate:", n2s(input_rate)
            if options.nsamples is None:
                print "Receiving samples until Ctrl-C"
            else:
                print "Receving", n2s(options.nsamples), "samples"
            if options.output_shorts:
                print "Writing 16-bit complex shorts"
            else:
                print "Writing 32-bit complex floats"
            print "Output filename:", filename