hfx2.py

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

	      self.button_8.SetValue(True)
	   elif self.active_button == 8:
	      self.active_button = 9
	      self.button_8.SetValue(False)
	      self.button_9.SetValue(True)
	   elif self.active_button == 9:
	      self.active_button = 5
	      self.button_9.SetValue(False)
	      self.button_5.SetValue(True)

    # Clicking one PM control button turns the rest off
    def on_button(self, event):
	id = event.GetId()
	if id == ID_BUTTON_5:
	   self.active_button = 5
	   self.button_6.SetValue(False)
	   self.button_7.SetValue(False)
	   self.button_8.SetValue(False)
	   self.button_9.SetValue(False)
	if id == ID_BUTTON_6:
	   self.active_button = 6
           self.button_5.SetValue(False)
           self.button_7.SetValue(False)
           self.button_8.SetValue(False)
           self.button_9.SetValue(False)
        if id == ID_BUTTON_7:
           self.active_button = 7
           self.button_5.SetValue(False)
           self.button_6.SetValue(False)
           self.button_8.SetValue(False)
           self.button_9.SetValue(False)
        if id == ID_BUTTON_8:
           self.active_button = 8
           self.button_5.SetValue(False)
           self.button_6.SetValue(False)
           self.button_7.SetValue(False)
           self.button_9.SetValue(False)
        if id == ID_BUTTON_9:
           self.active_button = 9
           self.button_5.SetValue(False)
           self.button_6.SetValue(False)
           self.button_7.SetValue(False)
           self.button_8.SetValue(False)

    # Make sure filter settings are legal
    def set_filter(self, event):
        slider = event.GetId()
        slider1 = self.slider_1.GetValue()
        slider2 = self.slider_2.GetValue()
        if slider == ID_SLIDER_1:
           if slider2 > (self.slider_1.GetValue() - 200) :
              self.slider_2.SetValue(slider1 - 200)
        elif slider == ID_SLIDER_2:
           if slider1 < (self.slider_2.GetValue() + 200) :
              self.slider_1.SetValue(slider2 + 200)
	self.filter()

    # Calculate taps and apply
    def filter(self):
        audio_coeffs = gr.firdes.complex_band_pass (
                1.0,    # gain
                self.af_sample_rate, # sample rate
                self.slider_2.GetValue(),    # low cutoff
                self.slider_1.GetValue(),   # high cutoff
                100,    # transition
                gr.firdes.WIN_HAMMING)  # window
        self.audio_filter.set_taps(audio_coeffs)

    def set_lsb(self, event):
	self.AM_mode = False
	self.xlate.set_center_freq( self.usrp_center - (self.frequency - self.tune_offset))
	self.sel_sb.set_k(1)
	self.sel_am.set_k(0)
	self.slider_1.SetValue(0)
	self.slider_2.SetValue(-3000)
	self.filter()

    def set_usb(self, event):
	self.AM_mode = False
	self.xlate.set_center_freq( self.usrp_center - (self.frequency - self.tune_offset))
	self.sel_sb.set_k(1)
	self.sel_am.set_k(0)
	self.slider_1.SetValue(3000)
	self.slider_2.SetValue(0)
	self.filter()

    def set_am(self, event):
	self.AM_mode = True
	self.xlate.set_center_freq( self.usrp_center - (self.frequency - self.tune_offset - 7.5e3))
	self.sel_sb.set_k(0)
	self.sel_am.set_k(1)
	self.slider_1.SetValue(12500)
	self.slider_2.SetValue(2500)
	self.filter()

    def set_cw(self, event):
	self.AM_mode = False
	self.xlate.set_center_freq( self.usrp_center - (self.frequency - self.tune_offset))
	self.AM_mode = False
	self.sel_sb.set_k(1)
	self.sel_am.set_k(0)
	self.slider_1.SetValue(-400)
	self.slider_2.SetValue(-800)
	self.filter()

    def set_volume(self, event):
        self.scale.set_k(math.pow(10.,((self.slider_4.GetValue()-500.)/100.)))

    def set_pga(self,event):
	if self.PLAY_FROM_USRP:
	   self.subdev.set_gain(self.slider_5.GetValue())

    def slide_tune(self, event):
        self.frequency = (self.f_slider_scale * self.slider_3.GetValue()) + self.f_slider_offset
	if self.AM_mode == False:
          self.xlate.set_center_freq( self.usrp_center - (self.frequency - self.tune_offset))
	else:
	  self.xlate.set_center_freq( self.usrp_center - (self.frequency - self.tune_offset - 7.5e3))
        self.spin_ctrl_1.SetValue(self.frequency)
	if self.button_12.GetValue():
	   self.auto_antenna_tune()

    def spin_tune(self, event):
	self.frequency = self.spin_ctrl_1.GetValue()
	if self.AM_mode == False:
           self.xlate.set_center_freq( self.usrp_center - (self.frequency - self.tune_offset))
	else:
	   self.xlate.set_center_freq( self.usrp_center - (self.frequency - self.tune_offset - 7.5e3))
        self.slider_3.SetValue(int((self.frequency-self.f_slider_offset)/self.f_slider_scale))
	if self.button_12.GetValue():
	   self.auto_antenna_tune()

    # Seek forwards in file
    def fwd(self, event):
	if self.PLAY_FROM_USRP == False:
	   self.src.seek(10000000,gr.SEEK_CUR)

    # Seek backwards in file
    def rew(self, event):
	if self.PLAY_FROM_USRP == False:
	   self.src.seek(-10000000,gr.SEEK_CUR)

    # Mouse over fft display - show frequency in tooltip
    def Mouse(self,event):
	if self.AM_mode:
	   fRel = ( event.GetX() - 330. ) / 14.266666 - 7.5
	else:
	   fRel = ( event.GetX() - 330. ) / 14.266666 
        self.fft.win.SetToolTip(wx.ToolTip(eng_notation.num_to_str(self.frequency + (fRel*1e3))))

    # Mouse clicked on fft display - change frequency 
    def Click(self,event):
        fRel = ( event.GetX() - 330. ) / 14.266666
	if self.AM_mode == False:
           self.frequency = self.frequency + (fRel*1e3)
	else:
	   self.frequency = self.frequency + (fRel*1e3) - 7.5e3
        self.spin_ctrl_1.SetValue(int(self.frequency))
        self.slider_3.SetValue(int((self.frequency-self.f_slider_offset)/self.f_slider_scale))
        if self.AM_mode == False:
	   self.xlate.set_center_freq ( self.usrp_center - ( self.frequency - self.tune_offset ))
	else:
	   self.xlate.set_center_freq( self.usrp_center - (self.frequency - self.tune_offset - 7.5e3))

    # Set power of AM sync carrier
    def am_carrier(self,event):
	scale = math.pow(10,(self.slider_6.GetValue())/50.)
	self.pll_carrier_scale.set_k(complex(scale,0))

    # Reset AT data and start calibrate over
    def AT_reset(self, event):
        self.xdata = []
        self.ydata = []

    # Save AT setting for a particular frequency
    def AT_calibrate(self, event):
        self.xdata.append(float(self.frequency))
        self.ydata.append(self.slider_7.GetValue())
        if len(self.xdata) > 1:
          self.m = []
          self.b = []
          for i in range(0,len(self.xdata)-1):
            self.m.append( (self.ydata[i+1] - self.ydata[i]) / (self.xdata[i+1] - self.xdata[i]) )
            self.b.append( self.ydata[i] - self.m[i] * self.xdata[i] )

    # Lookup calibrated points and calculate interpolated antenna tune voltage.
    # This is to automatically tune a narrowband loop antenna when the freq
    # is changed, to keep signals peaked.
    def auto_antenna_tune(self):
        for i in range(0,len(self.xdata)-1):
          if (self.frequency > self.xdata[i]) & (self.frequency < self.xdata[i+1]):
            self.slider_7.SetValue(self.m[i]*self.frequency + self.b[i])
        self.antenna_tune(0)

    # Slider to set loop antenna capacitance
    def antenna_tune(self, evt):
        if self.PLAY_FROM_USRP:
           self.src.write_aux_dac(0,3,self.slider_7.GetValue())

    # Timer events - check for web commands
    def OnUpdate(self):
      cmds = os.listdir("/var/www/cgi-bin/commands/")
      if cmds!=[]:
        if cmds[0]=='chfreq':
          fd=open("/var/www/cgi-bin/commands/chfreq","r")
          new=fd.readline()
          fd.close()
          if new!='':
            os.unlink("/var/www/cgi-bin/commands/chfreq")
            if ( int(new) >= self.f_lo ) & ( int(new) <= self.f_hi ):
               self.frequency = int(new)
               self.slider_3.SetValue(( self.frequency - self.f_slider_offset) / self.f_slider_scale )
               self.spin_ctrl_1.SetValue(self.frequency)
               if self.button_12.GetValue():
                 self.auto_antenna_tune()
               if self.AM_mode:
                 self.xlate.set_center_freq ( self.usrp_center - ( self.frequency - self.tune_offset - 7.5e3 ))
               else:
                 self.xlate.set_center_freq ( self.usrp_center - ( self.frequency - self.tune_offset ))

        if cmds[0]=='chvolume':
          fd=open("/var/www/cgi-bin/commands/chvolume","r")
          new=fd.readline()
          fd.close()
          if new!='':
            os.unlink("/var/www/cgi-bin/commands/chvolume")
            if ( int(new) >= 0 ) & ( int(new) <= 500 ):
               self.volume = int(new)
               self.slider_4.SetValue(self.volume)
               self.scale.set_k(math.pow(10.,((self.slider_4.GetValue()-500.)/100.)))

      else: # no new web commands, update state
        fh = open("/var/www/cgi-bin/state/freq","w")
        fh.write(str(int(self.frequency))+'\n')
        fh.close()
        fh = open("/var/www/cgi-bin/state/volume","w")
        fh.write(str(self.slider_4.GetValue())+'\n')
        fh.close()


# end of class MyFrame

# wx.Timer to check for web updates
class UpdateTimer(wx.Timer):
    def __init__(self, target, dur=1000):
        wx.Timer.__init__(self)
        self.target = target
        self.Start(dur)

    def Notify(self):
        """Called every timer interval"""
        if self.target:
            self.target.OnUpdate()


class MyApp(wx.App):
  def OnInit(self):
    frame = MyFrame(None, -1, "HF Explorer 2")
    frame.Show(True)
    self.SetTopWindow(frame)
    return True

app = MyApp(0)
app.MainLoop()