Beispiel #1
0
    def __init__(self, channel_rate, threshold):
        gr.hier_block2.__init__(self, "ppm_demod",
                              gr.io_signature(1, 1, gr.sizeof_gr_complex),
                              gr.io_signature(1, 1, 512))

        chan_rate = 8000000 # Minimum sample rate

        if channel_rate < chan_rate:
            raise ValueError, "Invalid channel rate %d. Must be 8000000 sps or higher" % (channel_rate)
        
        if channel_rate >= 10000000:
            chan_rate = 10000000    # Higher Performance Receiver

        # if rate is not supported then resample
        if channel_rate != chan_rate:
            interp = gru.lcm(channel_rate, chan_rate)/channel_rate
            decim  = gru.lcm(channel_rate, chan_rate)/chan_rate
            self.RESAMP = rational_resampler_ccf(self, interp, decim)

        # Calculate the leading edge threshold per sample time
        leading_edge = risetime_threshold_db/(chan_rate/data_rate)

        # Calculate the number of following samples above threshold needed to make a sample a valid pulse position
        valid_pulse_position = 2
        if chan_rate == 10000000:
            valid_pulse_position = 3

        # Demodulate AM with classic sqrt (I*I + Q*Q)
        self.MAG = gr.complex_to_mag()
        self.DETECT = air.ms_pulse_detect(leading_edge, threshold, valid_pulse_position) # Attack, Threshold, Pulsewidth
        self.SYNC = air.ms_preamble(chan_rate)
        self.FRAME = air.ms_framer(chan_rate)
        self.BIT   = air.ms_ppm_decode(chan_rate)
        self.PARITY = air.ms_parity()
        self.EC    =  air.ms_ec_brute()

        if channel_rate != chan_rate:
            # Resample the stream first
            self.connect(self, self.RESAMP, self.MAG, self.DETECT)
        else: 
            self.connect(self, self.MAG, self.DETECT)

        self.connect((self.DETECT, 0), (self.SYNC, 0))
        self.connect((self.DETECT, 1), (self.SYNC, 1))
        self.connect((self.SYNC, 0), (self.FRAME, 0))
        self.connect((self.SYNC, 1), (self.FRAME, 1))
        self.connect((self.FRAME, 0), (self.BIT, 0))
        self.connect((self.FRAME, 1), (self.BIT, 1))
        self.connect(self.BIT, self.PARITY, self.EC, self)
Beispiel #2
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("-R", "--rx-subdev-spec", type="subdev", default=None,
                          help="select USRP Rx side A or B (default=first one with a daughterboard)")
        parser.add_option("-d", "--decim", type="int", default=8,
                          help="set fgpa decimation rate to DECIM [default=%default]")
    	parser.add_option("-f", "--freq", type="eng_float", default=1090.0,
                          help="set receive frequency to MHz [default=%default]", metavar="FREQ")
        parser.add_option("-g", "--gain", type="eng_float", default=None,
                          help="set gain in dB (default is midpoint)")
        parser.add_option("-8", "--width-8", action="store_true", default=False,
                          help="Enable 8-bit samples across USB")
        parser.add_option("-n", "--frame-decim", type="int", default=1,
                          help="set oscope frame decimation factor to n [default=1]")
        parser.add_option("-v", "--v-scale", type="eng_float", default=200,
                          help="set oscope initial V/div to SCALE [default=%default]")
        parser.add_option("-t", "--t-scale", type="eng_float", default=24e-6,
                          help="set oscope initial s/div to SCALE [default=25us]")
    	parser.add_option("-T", "--thresh", type="int", default=10,
                          help="set valid pulse threshold to THRESH [default=%default]")
        (options, args) = parser.parse_args()
        if len(args) != 0:
            parser.print_help()
            sys.exit(1)

        self.show_debug_info = True

	options.freq *= 1e6

        # build the graph

	if options.decim < 8:
		self.fpga_filename="std_4rx_0tx.rbf" #Min decimation of this firmware is 4. contains 4 Rx paths without halfbands and 0 tx paths.
	       	self.u = usrp.source_c(decim_rate=options.decim, fpga_filename=self.fpga_filename)
	else :
                #standard fpga firmware "std_2rxhb_2tx.rbf" contains 2 Rx paths with halfband filters and 2 tx paths (the default) min decimation 8
        	self.u = usrp.source_c(decim_rate=options.decim)
        if options.rx_subdev_spec is None:
            options.rx_subdev_spec = pick_subdevice(self.u)
        self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))

        if options.width_8:
            width = 8
            shift = 8
            format = self.u.make_format(width, shift)
            #print "format =", hex(format)
            r = self.u.set_format(format)
            #print "set_format =", r

        # determine the daughterboard subdevice we're using
        self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
	#self.subdev.set_bw(5e6)  # only valid for dbsrx

	chan_rate = 8000000
        input_rate = self.u.adc_freq() / self.u.decim_rate()
	if input_rate < chan_rate:
            raise ValueError, "Invalid input rate %d. Must be 8000000 sps or higher" % (input_rate)
	if input_rate >= 10000000:
		chan_rate = 10000000    # Higher Performance Receiver
	# if rate is not supported then resample
	if input_rate != chan_rate:
		raise Error, "Resampling Unsupported"
		#interp = gru.lcm(input_rate, chan_rate)/input_rate
		#decim  = gru.lcm(input_rate, chan_rate)/chan_rate
		#print interp, decim
		#self.resamp = blks.rational_resampler_ccf(self, interp, decim)

	# Calculate the leading edge threshold per sample time
	leading_edge = risetime_threshold_db/(chan_rate/data_rate)
	# The number of following samples above threshold needed to make a sample a valid pulse position
	valid_pulse_position = 2
	if chan_rate == 10000000:
		valid_pulse_position = 3
	self.mag = gr.complex_to_mag()
	self.detect = air.ms_pulse_detect(leading_edge, options.thresh, valid_pulse_position)
	self.sync = air.ms_preamble(chan_rate)
	self.frame = air.ms_framer(chan_rate)
	self.cvt = air.ms_cvt_float()
        self.scope = scopesink2.scope_sink_f(self, panel, sample_rate=chan_rate,
                                            frame_decim=options.frame_decim,
                                            v_scale=options.v_scale,
                                            t_scale=options.t_scale)
	#if chan_rate == 10000000:
        #self.connect(self.u, self.resamp, self.mag, self.detect)
	#else :
        self.connect(self.u, self.mag, self.detect)
	self.connect((self.detect, 0), (self.sync, 0))
	self.connect((self.detect, 1), (self.sync, 1))
	self.connect((self.sync, 0), (self.frame, 0))
	self.connect((self.sync, 1), (self.frame, 1))
        self.connect((self.frame, 0), (self.cvt, 0))
        self.connect((self.frame, 1), (self.cvt, 1))
        self.connect((self.cvt, 0), (self.scope, 0))
        self.connect((self.cvt, 1), (self.scope,1))
        self.connect((self.cvt, 2), (self.scope,2))

        self._build_gui(vbox)

        # set initial values

        if options.gain is None:
            # if no gain was specified, use the mid-point in dB
            g = self.subdev.gain_range()
            options.gain = float(g[0]+g[1])/2


        self.set_gain(options.gain)

        if self.show_debug_info:
            self.myform['decim'].set_value(self.u.decim_rate())
            self.myform['fs@usb'].set_value(self.u.adc_freq() / self.u.decim_rate())
            self.myform['dbname'].set_value(self.subdev.name())
            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")