usrp_psr_receiver.py

这是用python语言写的一个数字广播的信号处理工具包。利用它

            self.folder_comb = gr.fft_filter_ccc(1,bogtaps)

        # Rational resampler
        self.folder_rr = blks.rational_resampler_fff(self, self.interp, self.decim)

        # Epoch folder bandpass
        bogtaps = Numeric.zeros(1, Numeric.Float64)
        self.folder_bandpass = gr.fir_filter_fff (1, bogtaps)

        # Epoch folder F2C/C2F
        self.folder_f2c = gr.float_to_complex()
        self.folder_c2f = gr.complex_to_float()

        # Epoch folder S2P
        self.folder_s2p = gr.serial_to_parallel (gr.sizeof_float, 
             self.folding*FOLD_MULT)

        # Epoch folder IIR Filter (produces average pulse profiles)
        self.folder_iir = gr.single_pole_iir_filter_ff(1.0/options.favg,
             self.folding*FOLD_MULT)

        #
        # Set all the epoch-folder goop up
        #
        self.set_folding_params()

        # 
        # Start connecting configured modules in the receive chain
        #

        # Connect raw USRP to de-dispersion filter, detector
        self.connect(self.u, self.dispfilt, self.detector)

        # Connect detector output to FIR LPF
        #  in two stages, followed by the FFT scope
        self.connect(self.detector, self.first,
            self.second, self.third, self.scope)

        # Connect audio output
        self.connect(self.first, self.volume)
        self.connect(self.volume, (self.audio, 0))
        self.connect(self.volume, (self.audio, 1))

        # Connect epoch folder
        if self.enable_comb_filter == True:
            self.connect (self.first, self.folder_bandpass, self.folder_rr,
                self.folder_f2c,
                self.folder_comb, self.folder_c2f,
                self.folder_s2p, self.folder_iir,
                self.chart)

        else:
            self.connect (self.first, self.folder_bandpass, self.folder_rr,
                self.folder_s2p, self.folder_iir, self.chart)

        # Connect baseband recording file (initially /dev/null)
        self.connect(self.u, self.tofloat, self.tochar, self.recording)

        # Connect pulse recording file (initially /dev/null)
        self.connect(self.first, self.toshort, self.pulse_recording)

        #
        # Build the GUI elements
        #
        self._build_gui(vbox)

        # Make GUI agree with command-line
        self.myform['average'].set_value(int(options.avg))
        self.myform['foldavg'].set_value(int(options.favg))


        # Make spectral averager agree with command line
        if options.avg != 1.0:
            self.scope.set_avg_alpha(float(1.0/options.avg))
            self.scope.set_average(True)


        # 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

        if options.freq is None:
            # if no freq was specified, use the mid-point
            r = self.subdev.freq_range()
            options.freq = float(r[0]+r[1])/2

        self.set_gain(options.gain)
        self.set_volume(-10.0)

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

        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['DM'].set_value(self.dm)
        self.myform['Doppler'].set_value(self.doppler)

        #
        # Start the timer that shows current LMST on the GUI
        #
        self.lmst_timer.Start(1000)


    def _set_status_msg(self, msg):
        self.frame.GetStatusBar().SetStatusText(msg, 0)

    def _build_gui(self, vbox):

        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])

        def _form_set_dm(kv):
            return self.set_dm(kv['DM'])

        def _form_set_doppler(kv):
            return self.set_doppler(kv['Doppler'])

        # Position the FFT or Waterfall
        vbox.Add(self.scope.win, 5, wx.EXPAND)
        vbox.Add(self.chart.win, 5, wx.EXPAND)

        # add control area at the bottom
        self.myform = myform = form.form()
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((7,0), 0, wx.EXPAND)
        vbox1 = wx.BoxSizer(wx.VERTICAL)
        myform['freq'] = form.float_field(
            parent=self.panel, sizer=vbox1, label="Center freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

        vbox1.Add((3,0), 0, 0)

        # To show current Local Mean Sidereal Time
        myform['lmst_high'] = form.static_text_field(
            parent=self.panel, sizer=vbox1, label="Current LMST", weight=1)
        vbox1.Add((3,0), 0, 0)

        # To show current spectral cursor data
        myform['spec_data'] = form.static_text_field(
            parent=self.panel, sizer=vbox1, label="Pulse Freq", weight=1)
        vbox1.Add((3,0), 0, 0)

        # To show best pulses found in FFT output
        myform['best_pulse'] = form.static_text_field(
            parent=self.panel, sizer=vbox1, label="Best freq", weight=1)
        vbox1.Add((3,0), 0, 0)

        vboxBogus = wx.BoxSizer(wx.VERTICAL)
        vboxBogus.Add ((2,0), 0, wx.EXPAND)
        vbox2 = wx.BoxSizer(wx.VERTICAL)
        g = self.subdev.gain_range()
        myform['gain'] = form.slider_field(parent=self.panel, sizer=vbox2, label="RF Gain",
                                           weight=1,
                                           min=int(g[0]), max=int(g[1]),
                                           callback=self.set_gain)

        vbox2.Add((6,0), 0, 0)
        myform['average'] = form.slider_field(parent=self.panel, sizer=vbox2, 
                    label="Spectral Averaging", weight=1, min=1, max=200, callback=self.set_averaging)
        vbox2.Add((6,0), 0, 0)
        myform['foldavg'] = form.slider_field(parent=self.panel, sizer=vbox2,
                    label="Folder Averaging", weight=1, min=1, max=20, callback=self.set_folder_averaging)
        vbox2.Add((6,0), 0, 0)
        myform['volume'] = form.quantized_slider_field(parent=self.panel, sizer=vbox2,
                    label="Audio Volume", weight=1, range=(-20, 0, 0.5), callback=self.set_volume)
        vbox2.Add((6,0), 0, 0)
        myform['DM'] = form.float_field(
            parent=self.panel, sizer=vbox2, label="DM", weight=1,
            callback=myform.check_input_and_call(_form_set_dm))
        vbox2.Add((6,0), 0, 0)
        myform['Doppler'] = form.float_field(
            parent=self.panel, sizer=vbox2, label="Doppler", weight=1,
            callback=myform.check_input_and_call(_form_set_doppler))
        vbox2.Add((6,0), 0, 0)


        # Baseband recording control
        buttonbox = wx.BoxSizer(wx.HORIZONTAL)
        self.record_control = form.button_with_callback(self.panel,
              label="Recording baseband: Off                           ",
              callback=self.toggle_recording)
        self.record_pulse_control = form.button_with_callback(self.panel,
              label="Recording pulses: Off                              ",
              callback=self.toggle_pulse_recording)

        buttonbox.Add(self.record_control, 0, wx.CENTER)
        buttonbox.Add(self.record_pulse_control, 0, wx.CENTER)
        vbox.Add(buttonbox, 0, wx.CENTER)
        hbox.Add(vbox1, 0, 0)
        hbox.Add(vboxBogus, 0, 0)
	hbox.Add(vbox2, wx.ALIGN_RIGHT, 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        self._build_subpanel(vbox)

        self.lmst_timer = wx.PyTimer(self.lmst_timeout)
        self.lmst_timeout()


    def _build_subpanel(self, vbox_arg):
        # build a secondary information panel (sometimes hidden)

        # FIXME figure out how to have this be a subpanel that is always
        # created, but has its visibility controlled by foo.Show(True/False)
        
        if not(self.show_debug_info):
            return

        panel = self.panel
        vbox = vbox_arg
        myform = self.myform

        #panel = wx.Panel(self.panel, -1)
        #vbox = wx.BoxSizer(wx.VERTICAL)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)
        myform['decim'] = form.static_float_field(
            parent=panel, sizer=hbox, label="Decim")

        hbox.Add((5,0), 1)
        myform['fs@usb'] = form.static_float_field(
            parent=panel, sizer=hbox, label="Fs@USB")

        hbox.Add((5,0), 1)
        myform['dbname'] = form.static_text_field(
            parent=panel, sizer=hbox)

        hbox.Add((5,0), 1)
        myform['baseband'] = form.static_float_field(
            parent=panel, sizer=hbox, label="Analog BB")

        hbox.Add((5,0), 1)
        myform['ddc'] = form.static_float_field(
            parent=panel, sizer=hbox, label="DDC")

        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        
        
    def set_freq(self, target_freq):
        """
        Set the center frequency we're interested in.

        @param target_freq: frequency in Hz
        @rypte: bool

        Tuning is a two step process.  First we ask the front-end to
        tune as close to the desired frequency as it can.  Then we use
        the result of that operation and our target_frequency to
        determine the value for the digital down converter.
        """
        r = usrp.tune(self.u, 0, self.subdev, target_freq)

        if r:
            self.myform['freq'].set_value(target_freq)     # update displayed value
            self.myform['baseband'].set_value(r.baseband_freq)
            self.myform['ddc'].set_value(r.dxc_freq)
            # Adjust self.frequency, and self.observing_freq
            # We pick up the difference between the current self.frequency
            #   and the just-programmed one, and use this to adjust
            #   self.observing_freq.  We have to do it this way to
            #   make the dedispersion filtering work out properly.
            delta = target_freq - self.frequency
            self.frequency = target_freq
            self.observing_freq += delta

            # Now that we're adjusted, compute a new dispfilter, and
            #   set the taps for the FFT filter.
            ntaps = self.compute_disp_ntaps(self.dm, self.bw, self.observing_freq)
            self.disp_taps = Numeric.zeros(ntaps, Numeric.Complex64)
            self.compute_dispfilter(self.dm,self.doppler,self.bw,
                self.observing_freq)
            self.dispfilt.set_taps(self.disp_taps)

            return True

        return False

    # Callback for gain-setting slider
    def set_gain(self, gain):
        self.myform['gain'].set_value(gain)     # update displayed value
        self.subdev.set_gain(gain)


    def set_volume(self, vol):
        self.myform['volume'].set_value(vol)
        self.volume.set_k((10**(vol/10))/8192)

    # Callback for spectral-averaging slider
    def set_averaging(self, avval):
        self.myform['average'].set_value(avval)
        self.scope.set_avg_alpha(1.0/(avval))
        self.scope.set_average(True)

    def set_folder_averaging(self, avval):
        self.myform['foldavg'].set_value(avval)
        self.folder_iir.set_taps(1.0/avval)

    # Timer callback to update LMST display
    def lmst_timeout(self):
         self.locality.date = ephem.now()
         sidtime = self.locality.sidereal_time()
         self.myform['lmst_high'].set_value(str(ephem.hours(sidtime)))

    #
    # Turn recording on/off
    # Called-back by "Recording" button
    #
    def toggle_recording(self):
        # Pick up current LMST
        self.locality.date = ephem.now()
        sidtime = self.locality.sidereal_time()

        # Pick up localtime, for generating filenames
        foo = time.localtime()

        # Generate filenames for both data and header file
        filename = "%04d%02d%02d%02d%02d.pdat" % (foo.tm_year, foo.tm_mon,
           foo.tm_mday, foo.tm_hour, foo.tm_min)
        hdrfilename = "%04d%02d%02d%02d%02d.phdr" % (foo.tm_year, foo.tm_mon,
           foo.tm_mday, foo.tm_hour, foo.tm_min)

        # Current recording?  Flip state
        if (self.recording_state == True):
          self.recording_state = False
          self.record_control.SetLabel("Recording baseband: Off                           ")
          self.recording.close()
        # Not recording?
        else:
          self.recording_state = True
          self.record_control.SetLabel("Recording baseband to: "+filename)

          # Cause gr_file_sink object to accept new filename
          #   note use of self.prefix--filename prefix from
          #   command line (defaults to ./)
          #
          self.recording.open (self.prefix+filename)

          #
          # We open the header file as a regular file, write header data,
          #   then close
          hdrf = open(self.prefix+hdrfilename, "w")
          hdrf.write("receiver center frequency: "+str(self.frequency)+"\n")
          hdrf.write("observing frequency: "+str(self.observing_freq)+"\n")
          hdrf.write("DM: "+str(self.dm)+"\n")
          hdrf.write("doppler: "+str(self.doppler)+"\n")

          hdrf.write("sidereal: "+str(ephem.hours(sidtime))+"\n")
          hdrf.write("bandwidth: "+str(self.u.adc_freq() / self.u.decim_rate())+"\n")
          hdrf.write("sample type: complex_char\n")
          hdrf.write("sample size: "+str(gr.sizeof_char*2)+"\n")
          hdrf.close()
    #
    # Turn recording on/off
    # Called-back by "Recording" button
    #
    def toggle_pulse_recording(self):
        # Pick up current LMST
        self.locality.date = ephem.now()