Exemple #1
0
    def _build_gui(self, vbox):

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

        def _form_set_freq2(kv):
            return self.set_freq2(kv['freq2'])            
        vbox.Add(self.scope.win, 10, wx.EXPAND)
        
        # add control area at the bottom
        self.myform = myform = form.form()
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0, 0)
        myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Center freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))
        if self.num_inputs==2:
          myform['freq2'] = form.float_field(
              parent=self.panel, sizer=hbox, label="Center freq2", weight=1,
              callback=myform.check_input_and_call(_form_set_freq2, self._set_status_msg))          
          hbox.Add((5,0), 0, 0)
        g = self.subdev.gain_range()
        myform['gain'] = form.slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                           weight=3,
                                           min=int(g[0]), max=int(g[1]),
                                           callback=self.set_gain)

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

        self._build_subpanel(vbox)
Exemple #2
0
    def make_layout(self):
        bspace = 10
        self.topbox.SetOrientation(wx.VERTICAL)
        vbox = wx.BoxSizer(wx.VERTICAL)

        """ SNR Penalty """
        box = wx.BoxSizer(wx.HORIZONTAL)
        self.make_label("SNR Penalty (dB)", box, 81)
        p = self.GetSNRPenalty()
        print "SNR Penalty =", p
        self.fsnr = form.float_field(self, box, value=p, \
                                callback=self.SetSNRPenalty)
        self.AddParam('snr penalty', self.SetSNRPenalty)
        vbox.Add(box, 0, wx.ALIGN_LEFT|wx.BOTTOM, border=bspace)

        """ Condition Penalty """
        box = wx.BoxSizer(wx.HORIZONTAL)
        self.make_label("Condition Penalty (0.0-1.0)", box, 20)
        p = self.GetConditionPenalty()
        print "Condition Penalty =", p
        self.fcond = form.float_field(self, box, value=p, \
                                callback=self.SetConditionPenalty)
        self.AddParam('condition penalty', self.SetConditionPenalty)
        vbox.Add(box, 0, wx.ALIGN_LEFT)
        
        self.topbox.Add(vbox, 0, wx.ALIGN_LEFT|wx.ALL, border=2*bspace)
        self.Fit()
    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)
        
        def _form_set_samp_rate(kv):
            return self.set_samp_rate(kv['samprate'])

        if not(self.show_debug_info):
            return

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

        hbox = wx.BoxSizer(wx.HORIZONTAL)

        hbox.Add((5,0), 0)
        myform['samprate'] = form.float_field(
            parent=panel, sizer=hbox, label="Sample Rate",
            callback=myform.check_input_and_call(_form_set_samp_rate,
                                                 self._set_status_msg))

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

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

        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)
Exemple #4
0
    def _build_gui(self, vbox):

        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])
            
        vbox.Add(self.scope.win, 10, wx.EXPAND)
        
        # add control area at the bottom
        self.myform = myform = form.form()
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0, 0)
        myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Center freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

        hbox.Add((5,0), 0, 0)
        g = self.u.get_gain_range()

	# some configurations don't have gain control
	if g.stop() > g.start():
    	    myform['gain'] = form.slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                               weight=3,
                                               min=int(g.start()), max=int(g.stop()),
                                               callback=self.set_gain)

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

        self._build_subpanel(vbox)
Exemple #5
0
    def _build_gui(self, vbox):
        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])

        vbox.Add(self.scope.win, 10, wx.EXPAND)

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

        hbox.Add((5, 0), 0, 0)
        g = self.subdev.gain_range()
        myform['gain'] = form.slider_field(parent=self.panel,
                                           sizer=hbox,
                                           label="Gain",
                                           weight=3,
                                           min=int(g[0]),
                                           max=int(g[1]),
                                           callback=self.set_gain)

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

        self._build_subpanel(vbox)
Exemple #6
0
    def _build_gui(self, vbox):

        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])
            
        vbox.Add(self.scope.win, 1, wx.EXPAND)	# Proportion used to be 10
        
        # add control area at the bottom
        self.myform = myform = form.form()
        hbox = wx.BoxSizer(wx.HORIZONTAL)	# Create row sizer

        hbox.Add((5,0), 0, 0)

        myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Center freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

        myform['antenna'] = form.radiobox_field(parent=self.panel, sizer=hbox, label="Antenna",
            value=None, callback=self.set_antenna_callback,
            choices=["TX/RX", "RX2", "RXA", "RXB", "RXAB"],major_dimension=5, weight=3)

        hbox.Add((5,0), 0, 0)

        g = self.subdev.gain_range()
        myform['gain'] = form.slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                           weight=6, # 3
                                           min=int(g[0]), max=int(g[1]),
                                           callback=self.set_gain)

        hbox.Add((5,0), 0, 0)

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

        self._build_subpanel(vbox)
Exemple #7
0
	def _build_gui(self, vbox, usrp_rate, audio_rate):

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

		if 1:
			self.fft = fftsink2.fft_sink_f (self.panel, title="Post FM Demod",
				fft_size=512, sample_rate=usrp_rate, y_per_div=10, ref_level=0)
			self.connect (self.fm_demod, self.fft)
			vbox.Add (self.fft.win, 4, wx.EXPAND)
		if 0:
			self.scope = scopesink2.scope_sink_f(self.panel, title="RDS timedomain",
				sample_rate=usrp_rate, num_inputs=2)
			self.connect (self.rds_bb_filter, (rds_scope,1))
			self.connect (self.rds_clock, (rds_scope,0))
			vbox.Add(self.scope.win, 4, wx.EXPAND)

		self.rdspanel = rdsPanel(self.msgq, self.panel)
		vbox.Add(self.rdspanel, 1, wx.EXPAND|wx.TOP|wx.BOTTOM, 20)

		# control area form at bottom
		self.myform = form.form()

		# 1st line
		hbox = wx.BoxSizer(wx.HORIZONTAL)
		self.myform.btn_down = wx.Button(self.panel, -1, "<<")
		self.myform.btn_down.Bind(wx.EVT_BUTTON, self.Seek_Down)
		hbox.Add(self.myform.btn_down, 0)
		self.myform['freq'] = form.float_field(
			parent=self.panel, sizer=hbox, label="Freq", weight=0,
			callback=self.myform.check_input_and_call(_form_set_freq, self._set_status_msg))
		hbox.Add((5,0), 0)
		self.myform.btn_up = wx.Button(self.panel, -1, ">>")
		self.myform.btn_up.Bind(wx.EVT_BUTTON, self.Seek_Up)
		hbox.Add(self.myform.btn_up, 0)
		self.myform['freq_slider'] = form.quantized_slider_field(
			parent=self.panel, sizer=hbox, weight=3,
			range=(87.5e6, 108e6, 0.1e6), callback=self.set_freq)
		hbox.Add((5,0), 0)
		vbox.Add(hbox, 0, wx.EXPAND)


		# 2nd line
		hbox = wx.BoxSizer(wx.HORIZONTAL)
		hbox.Add((5,0), 0)
		self.myform['volume'] = form.quantized_slider_field(parent=self.panel, sizer=hbox,
			label="Volume", weight=3, range=self.volume_range(), callback=self.set_vol)
		hbox.Add((5,0), 1)
		self.myform['gain'] = form.quantized_slider_field(parent=self.panel, sizer=hbox,
			label="Gain", weight=3, range=self.subdev.gain_range(), callback=self.set_gain)
		hbox.Add((5,0), 0)
		vbox.Add(hbox, 0, wx.EXPAND)
    def _create_set_freq(self):

        def _set_freq(kv):
            return self.flexrf.set_freq(kv['freq'])[0]

        sbs = wx.StaticBoxSizer(wx.StaticBox(self.panel), wx.HORIZONTAL)
        sbs.Add((5,0), 0.1)       # stretchy space
        #sbs.Add(wx.StaticText(self.panel, -1, "set_freq "), 0, 0)
        #sbs.Add((5,0), 0.1)       # stretchy space
        myform = form.form()
        myform['freq'] = form.float_field(self.panel, sbs, "Set Frequency")
        sbs.Add((5,0), 0.1)       # stretchy space
        sbs.Add(form.button_with_callback(self.panel, "Do It!",
                                          self._generic_doit(_set_freq, myform)), 1, wx.EXPAND)
        sbs.Add((5,0), 0.1)       # stretchy space
        self.vbox.Add(sbs, 0, wx.EXPAND)
Exemple #9
0
    def _create_set_freq(self):
        def _set_freq(kv):
            return self.flexrf.set_freq(kv['freq'])[0]

        sbs = wx.StaticBoxSizer(wx.StaticBox(self.panel), wx.HORIZONTAL)
        sbs.Add((5, 0), 0.1)  # stretchy space
        #sbs.Add(wx.StaticText(self.panel, -1, "set_freq "), 0, 0)
        #sbs.Add((5,0), 0.1)       # stretchy space
        myform = form.form()
        myform['freq'] = form.float_field(self.panel, sbs, "Set Frequency")
        sbs.Add((5, 0), 0.1)  # stretchy space
        sbs.Add(
            form.button_with_callback(self.panel, "Do It!",
                                      self._generic_doit(_set_freq, myform)),
            1, wx.EXPAND)
        sbs.Add((5, 0), 0.1)  # stretchy space
        self.vbox.Add(sbs, 0, wx.EXPAND)
    def _build_gui(self, vbox):

        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])
            
        vbox.Add(self.scope.win, 10, wx.EXPAND)
        
        # add control area at the bottom
        self.myform = myform = form.form()
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0, 0)
        myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Center freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

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

        self._build_subpanel(vbox)
    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)

        def _form_set_samp_rate(kv):
            return self.set_samp_rate(kv['samprate'])

        if not (self.show_debug_info):
            return

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

        hbox = wx.BoxSizer(wx.HORIZONTAL)

        hbox.Add((5, 0), 0)
        myform['samprate'] = form.float_field(
            parent=panel,
            sizer=hbox,
            label="Sample Rate",
            callback=myform.check_input_and_call(_form_set_samp_rate,
                                                 self._set_status_msg))

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

        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 _build_subpanel3(self, vbox_arg):

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

	def _form_set_nsamples(kv):
            return self.set_nsamples(kv['numsamp'])



 

	def _form_set_filename(kv):
            return self.set_filename(kv['fname'])

        hbox = wx.BoxSizer(wx.HORIZONTAL)
	hbox.Add((5,0), 0)
        myform['fname'] = form.text_field(
            parent=panel, sizer=hbox, label="Filename",
            callback=myform.check_input_and_call(_form_set_filename,
                                                 self._set_status_msg))
	hbox.Add((5,0), 0)
        myform['numsamp'] = form.float_field(
            parent=panel, sizer=hbox, label="Number of Samples",
            callback=myform.check_input_and_call(_form_set_nsamples,
                                                 self._set_status_msg))



        hbox.Add((10,0), 0)

	#Create a button to save data
        #myform['savefile'] = form.button_with_callback(parent=panel,      label="Save Data", callback=myform.check_input_and_call(self.set_gain))
        myform['savefile'] = form.checkbox_field(parent=panel,        label="Save Data", sizer=hbox, callback=self.save_data)
       
        

        vbox.AddSpacer(5)

        vbox.Add(hbox, 0, wx.EXPAND)
        vbox.AddSpacer(5)
    def _build_gui(self, vbox, usrp_rate, demod_rate, audio_rate):

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


        if 0:
            self.src_fft = fftsink.fft_sink_c (self, self.panel, title="Data from USRP",
                                               fft_size=512, sample_rate=usrp_rate)
            self.connect (self.src, self.src_fft)
            vbox.Add (self.src_fft.win, 4, wx.EXPAND)

        if 0:
            post_demod_fft = fftsink.fft_sink_f (self, self.panel, title="Post Demod",
                                                  fft_size=512, sample_rate=demod_rate,
                                                  y_per_div=10, ref_level=-40)
            self.connect (self.am_demod, post_demod_fft)
            vbox.Add (post_demod_fft.win, 4, wx.EXPAND)

        if 0:
            post_filt_fft = fftsink.fft_sink_f (self, self.panel, title="Post Filter", 
                                                fft_size=512, sample_rate=audio_rate,
                                                y_per_div=10, ref_level=-40)
            self.connect (self.set_blacklevel, post_filt)
            vbox.Add (fft_win4, 4, wx.EXPAND)

        
        # control area form at bottom
        self.myform = myform = form.form()

        if not (self.u is None):
          hbox = wx.BoxSizer(wx.HORIZONTAL)
          hbox.Add((5,0), 0)
          myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

          hbox.Add((5,0), 0)
          myform['freq_slider'] = \
              form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
                                        range=(self.tv_freq_min, self.tv_freq_max, 0.25e6),
                                        callback=self.set_freq)
          hbox.Add((5,0), 0)
          vbox.Add(hbox, 0, wx.EXPAND)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)

        myform['contrast'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Contrast",
                                        weight=3, range=(-2.0, 2.0, 0.1),
                                        callback=self.set_contrast)
        hbox.Add((5,0), 1)

        myform['brightness'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Brightness",
                                        weight=3, range=(-255.0, 255.0, 1.0),
                                        callback=self.set_brightness)
        hbox.Add((5,0), 0)

        if not (self.u is None):
          g = self.u.get_gain_range()
          myform['gain'] = \
              form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=(g.start(), g.stop(), g.step()),
                                        callback=self.set_gain)
          hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        try:
            self.knob = powermate.powermate(self.frame)
            self.rot = 0
            powermate.EVT_POWERMATE_ROTATE (self.frame, self.on_rotate)
            powermate.EVT_POWERMATE_BUTTON (self.frame, self.on_button)
        except:
            print "FYI: No Powermate or Contour Knob found"
Exemple #14
0
    def _build_gui(self, vbox, usrp_rate, demod_rate, audio_rate):

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


        if 0:
            self.src_fft = fftsink.fft_sink_c (self, self.panel, title="Data from USRP",
                                               fft_size=512, sample_rate=usrp_rate)
            self.connect (self.src, self.src_fft)
            vbox.Add (self.src_fft.win, 4, wx.EXPAND)

        if 0:
            post_demod_fft = fftsink.fft_sink_f (self, self.panel, title="Post Demod",
                                                  fft_size=512, sample_rate=demod_rate,
                                                  y_per_div=10, ref_level=-40)
            self.connect (self.am_demod, post_demod_fft)
            vbox.Add (post_demod_fft.win, 4, wx.EXPAND)

        if 0:
            post_filt_fft = fftsink.fft_sink_f (self, self.panel, title="Post Filter",
                                                fft_size=512, sample_rate=audio_rate,
                                                y_per_div=10, ref_level=-40)
            self.connect (self.set_blacklevel, post_filt)
            vbox.Add (fft_win4, 4, wx.EXPAND)


        # control area form at bottom
        self.myform = myform = form.form()

        if not (self.u is None):
          hbox = wx.BoxSizer(wx.HORIZONTAL)
          hbox.Add((5,0), 0)
          myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

          hbox.Add((5,0), 0)
          myform['freq_slider'] = \
              form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
                                        range=(self.tv_freq_min, self.tv_freq_max, 0.25e6),
                                        callback=self.set_freq)
          hbox.Add((5,0), 0)
          vbox.Add(hbox, 0, wx.EXPAND)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)

        myform['contrast'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Contrast",
                                        weight=3, range=(-2.0, 2.0, 0.1),
                                        callback=self.set_contrast)
        hbox.Add((5,0), 1)

        myform['brightness'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Brightness",
                                        weight=3, range=(-255.0, 255.0, 1.0),
                                        callback=self.set_brightness)
        hbox.Add((5,0), 0)

        if not (self.u is None):
          g = self.u.get_gain_range()
          myform['gain'] = \
              form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=(g.start(), g.stop(), g.step()),
                                        callback=self.set_gain)
          hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        try:
            self.knob = powermate.powermate(self.frame)
            self.rot = 0
            powermate.EVT_POWERMATE_ROTATE (self.frame, self.on_rotate)
            powermate.EVT_POWERMATE_BUTTON (self.frame, self.on_button)
        except:
            print "FYI: No Powermate or Contour Knob found"
Exemple #15
0
    def _build_gui(self, vbox, usrp_rate, demod_rate, audio_rate):
        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])

        if 1:
            self.src_fft = fftsink2.fft_sink_c(self.panel,
                                               title="Data from USRP2",
                                               fft_size=512,
                                               sample_rate=usrp_rate,
                                               ref_scale=1.0,
                                               ref_level=0,
                                               y_divs=12)
            self.connect(self.u, self.src_fft)
            vbox.Add(self.src_fft.win, 4, wx.EXPAND)

        if 1:
            post_filt_fft = fftsink2.fft_sink_f(self.panel,
                                                title="Post Demod",
                                                fft_size=1024,
                                                sample_rate=usrp_rate,
                                                y_per_div=10,
                                                ref_level=0)
            self.connect(self.guts.fm_demod, post_filt_fft)
            vbox.Add(post_filt_fft.win, 4, wx.EXPAND)

        if 0:
            post_deemph_fft = fftsink2.fft_sink_f(self.panel,
                                                  title="Post Deemph",
                                                  fft_size=512,
                                                  sample_rate=audio_rate,
                                                  y_per_div=10,
                                                  ref_level=-20)
            self.connect(self.guts.deemph, post_deemph_fft)
            vbox.Add(post_deemph_fft.win, 4, wx.EXPAND)

        # control area form at bottom
        self.myform = myform = form.form()

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)
        myform['freq'] = form.float_field(parent=self.panel,
                                          sizer=hbox,
                                          label="Freq",
                                          weight=1,
                                          callback=myform.check_input_and_call(
                                              _form_set_freq,
                                              self._set_status_msg))

        hbox.Add((5, 0), 0)
        myform['freq_slider'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
                                        range=(87.9e6, 108.1e6, 0.1e6),
                                        callback=self.set_freq)
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)

        myform['volume'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
                                        weight=3, range=self.volume_range(),
                                        callback=self.set_vol)
        hbox.Add((5, 0), 1)

        myform['gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=self.u.gain_range(),
                                        callback=self.set_gain)
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        try:
            self.knob = powermate.powermate(self.frame)
            self.rot = 0
            powermate.EVT_POWERMATE_ROTATE(self.frame, self.on_rotate)
            powermate.EVT_POWERMATE_BUTTON(self.frame, self.on_button)
        except:
            pass
Exemple #16
0
    def _build_gui(self, vbox, usrp_rate, demod_rate, audio_rate):
        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])

        if 1:
            self.src_fft = fftsink2.fft_sink_c(self.panel,
                                               title="Data from USRP",
                                               fft_size=512,
                                               sample_rate=usrp_rate,
                                               ref_scale=32768.0,
                                               ref_level=0,
                                               y_divs=12)
            self.connect(self.u, self.src_fft)
            vbox.Add(self.src_fft.win, 4, wx.EXPAND)

        if 1:
            post_fm_demod_fft = fftsink2.fft_sink_f(self.panel,
                                                    title="Post FM Demod",
                                                    fft_size=512,
                                                    sample_rate=demod_rate,
                                                    y_per_div=10,
                                                    ref_level=0)
            self.connect(self.guts.fm_demod, post_fm_demod_fft)
            vbox.Add(post_fm_demod_fft.win, 4, wx.EXPAND)

        if 0:
            post_stereo_carrier_generator_fft = fftsink2.fft_sink_c(
                self.panel,
                title="Post Stereo_carrier_generator",
                fft_size=512,
                sample_rate=audio_rate,
                y_per_div=10,
                ref_level=0)
            self.connect(self.guts.stereo_carrier_generator,
                         post_stereo_carrier_generator_fft)
            vbox.Add(post_stereo_carrier_generator_fft.win, 4, wx.EXPAND)

        if 0:
            post_deemphasis_left = fftsink2.fft_sink_f(
                self.panel,
                title="Post_Deemphasis_Left",
                fft_size=512,
                sample_rate=audio_rate,
                y_per_div=10,
                ref_level=0)
            self.connect(self.guts.deemph_Left, post_deemphasis_left)
            vbox.Add(post_deemphasis_left.win, 4, wx.EXPAND)

        if 0:
            post_deemphasis_right = fftsink2.fft_sink_f(
                self.panel,
                title="Post_Deemphasis_Right",
                fft_size=512,
                sample_rate=audio_rate,
                y_per_div=10,
                ref_level=-20)
            self.connect(self.guts.deemph_Left, post_deemphasis_right)
            vbox.Add(post_deemphasis_right.win, 4, wx.EXPAND)

        if 0:
            LmR_fft = fftsink2.fft_sink_f(self.panel,
                                          title="LmR",
                                          fft_size=512,
                                          sample_rate=audio_rate,
                                          y_per_div=10,
                                          ref_level=-20)
            self.connect(self.guts.LmR_real, LmR_fft)
            vbox.Add(LmR_fft.win, 4, wx.EXPAND)

        if 0:
            self.scope = scopesink2.scope_sink_f(self.panel,
                                                 sample_rate=demod_rate)
            self.connect(self.guts.fm_demod, self.scope)
            vbox.Add(self.scope.win, 4, wx.EXPAND)

        # control area form at bottom
        self.myform = myform = form.form()

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)
        myform['freq'] = form.float_field(parent=self.panel,
                                          sizer=hbox,
                                          label="Freq",
                                          weight=1,
                                          callback=myform.check_input_and_call(
                                              _form_set_freq,
                                              self._set_status_msg))

        hbox.Add((5, 0), 0)
        myform['freq_slider'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
                                        range=(self.fm_freq_min, self.fm_freq_max, 0.1e6),
                                        callback=self.set_freq)
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)

        myform['volume'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
                                        weight=3, range=self.volume_range(),
                                        callback=self.set_vol)
        hbox.Add((5, 0), 1)

        g = self.u.get_gain_range()
        myform['gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=(g.start(), g.stop(), g.step()),
                                        callback=self.set_gain)
        hbox.Add((5, 0), 0)

        myform['sqlch_thrsh'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Stereo Squelch Threshold",
                                        weight=3, range=(0.0,1.0,0.01),
                                        callback=self.set_squelch)
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        try:
            self.knob = powermate.powermate(self.frame)
            self.rot = 0
            powermate.EVT_POWERMATE_ROTATE(self.frame, self.on_rotate)
            powermate.EVT_POWERMATE_BUTTON(self.frame, self.on_button)
        except:
            print "FYI: No Powermate or Contour Knob found"
Exemple #17
0
    def _build_gui(self, vbox):

        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])
            
        vbox.Add(self.scope.win, 10, wx.EXPAND)
        
        # add control area at the bottom
        self.myform = myform = form.form()
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0, 0)
        myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Center freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq,
                                                 self._set_status_msg))

        hbox.Add((5,0), 0, 0)
        g = self.u.get_gain_range()

        # some configurations don't have gain control
        if g.stop() <= g.start():
            glow = 0.0
            ghigh = 1.0
            
        else:
            glow = g.start()
            ghigh = g.stop()
            
        myform['gain'] = form.slider_field(parent=self.panel,
                                               sizer=hbox, label="Gain",
                                               weight=3,
                                               min=int(glow), max=int(ghigh),
                                               callback=self.set_gain)

        try:
            mboard_id = self.u.get_usrp_info().get("mboard_id").split(" ")[0]
            mboard_serial = self.u.get_usrp_info().get("mboard_serial")
            if mboard_serial == "":
                mboard_serial = "no serial"
            dboard_id = self.u.get_usrp_info().get("rx_id").split(" ")[0].split(",")[0]
            dboard_serial = self.u.get_usrp_info().get("rx_serial")
            if dboard_serial == "":
                dboard_serial = "no serial"
            subdev = self.u.get_subdev_spec()
            antenna = self.u.get_antenna()

            usrp_config_val = "%s (%s), %s (%s, %s, %s)" % (mboard_id, mboard_serial, dboard_id, dboard_serial, subdev, antenna)
        except:
            usrp_config_val = "Not implemented in this version."

        uhd_box = forms.static_box_sizer(parent=self.panel,
                                         label="UHD (%s)" % (uhd.get_version_string()),
                                         orient=wx.HORIZONTAL)
        usrp_config_form = forms.static_text(
            parent=self.panel,
            sizer=uhd_box,
            value=usrp_config_val,
            label="USRP",
            converter=forms.str_converter(),
        )
        vbox.Add(uhd_box, 0, wx.EXPAND)
        vbox.AddSpacer(5)

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

        self._build_subpanel(vbox)
Exemple #18
0
    def make_control(self):
        bspace = 10
        vbox = wx.BoxSizer(wx.VERTICAL)
        
        """ Frequency """
        nbox = wx.BoxSizer(wx.HORIZONTAL)
        self.make_label("Carrier Frequency", nbox, 46)
        self.freq = form.float_field (self, nbox, \
                value=default_control_setup.d_options['freq'], callback=self.SetFreq)
        self.AddParam('freq',self.SetFreq)
        self.SetParam('freq', self.options.freq)
        vbox.AddSpacer((10,10) )
        vbox.Add(nbox, 0, wx.ALIGN_LEFT|wx.BOTTOM|wx.LEFT|wx.RIGHT, border=bspace)
        
        """ Sample Rate """
        nbox = wx.BoxSizer(wx.HORIZONTAL)
        self.make_label("Sample Rate", nbox, 80)
        self.sample_rate = form.float_field (self, nbox, \
                value=self.options.sample_rate, callback=self.SetSampleRate)
        self.AddParam('sample_rate', self.SetSampleRate)
        self.SetParam('sample_rate', self.options.sample_rate)
        vbox.Add(nbox, 0, wx.ALIGN_LEFT|wx.BOTTOM|wx.LEFT|wx.RIGHT, border=bspace)
        
        """ Upsampling Factor """
        nbox = wx.BoxSizer(wx.HORIZONTAL)
        self.make_label("Upsampling Factor", nbox, 43)
        self.upsample = form.int_field (self, nbox, \
                value=self.options.upsample, callback=self.SetUpsample)
        self.AddParam('upsampling_factor', self.SetUpsample)
        self.SetParam('upsampling_factor', self.options.upsample)
        vbox.Add(nbox, 0, wx.ALIGN_LEFT|wx.BOTTOM|wx.LEFT|wx.RIGHT, border=bspace)
        self.upsamplebox = nbox

        """ TxGain """
        box = wx.BoxSizer(wx.HORIZONTAL)
        self.txgain = form.slider_field(self, box, "Transmit Gain",\
                value=self.options.tx_gain, callback=self.SetTxGain,
                min=0, max=10000.0)
        box.AddSpacer((10,10) )
        self.autotxgain = form.checkbox_field(self, box, "auto", \
                value=self.options.auto_tx_gain, callback=self.SetAutoTxGain, \
                weight=0)
        box.GetItem(self.autotxgain.f).SetFlag(wx.ALIGN_LEFT|wx.ALIGN_BOTTOM)
        self.AddParam('auto_tx_gain', self.SetAutoTxGain)
        self.SetParam('auto_tx_gain', self.options.auto_tx_gain)
        self.AddParam('tx_gain', self.SetTxGain)
        self.SetParam('tx_gain', self.options.tx_gain)
        vbox.Add(box, 0, wx.ALIGN_LEFT|wx.BOTTOM|wx.LEFT|wx.RIGHT, border=bspace)
        self.txgainbox = box

        """ RxGain """
        box = wx.BoxSizer(wx.HORIZONTAL)
        self.rxgain = form.slider_field(self, box, "Receive Gain", \
                value=self.options.rx_gain, callback=self.SetRxGain,
                min=0, max=75)
        self.AddParam('rx_gain', self.SetRxGain)
        self.SetParam('rx_gain', self.options.rx_gain)
        vbox.Add(box, 0, wx.ALIGN_LEFT|wx.BOTTOM|wx.LEFT|wx.RIGHT, border=bspace)

        self.topbox.Add(vbox, 0, wx.GROW)
        self.cbox = vbox
        self.Fit()
Exemple #19
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()
Exemple #20
0
    def _build_gui(self, vbox):

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

        self.src_fft = None
        if 1:
            self.src_fft = fftsink2.fft_sink_c(self.panel, title="Data from MSDD",
                                               fft_size=512, sample_rate=512)
#            self.s2f1 = gr.short_to_float()
#            self.scope = scopesink2.scope_sink_f(self.panel, sample_rate=self.sample_rate*self.fft_size)
            
            self.connect (self.u, self.src_fft)
            #self.connect (self.s2f1, self.scope)
            vbox.Add (self.src_fft.win, 4, wx.EXPAND)
#
#        if 1:
#            post_filt_fft = fftsink2.fft_sink_f(self.panel, title="Post Demod", 
#                                                fft_size=1024, sample_rate=usrp_rate,
#                                                y_per_div=10, ref_level=0)
#            self.connect (self.guts.fm_demod, post_filt_fft)
#            vbox.Add (post_filt_fft.win, 4, wx.EXPAND)
#
#        if 0:
#            post_deemph_fft = fftsink2.fft_sink_f(self.panel, title="Post Deemph",
#                                                  fft_size=512, sample_rate=audio_rate,
#                                                  y_per_div=10, ref_level=-20)
#            self.connect (self.guts.deemph, post_deemph_fft)
#            vbox.Add (post_deemph_fft.win, 4, wx.EXPAND)

        
        # control area form at bottom
        self.myform = myform = form.form()

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)
        myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

        hbox.Add((5,0), 0)
        myform['freq_slider'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
                                        range=(30e6, 6e9, 1e6),
                                        callback=self.set_freq)
        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)
#
#        myform['volume'] = \
#            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
#                                        weight=3, range=self.volume_range(),
#                                        callback=self.set_vol)
#        hbox.Add((5,0), 1)

        myform['gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=self.gain_range,
                                        callback=self.set_gain)
        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)
Exemple #21
0
    def _build_gui(self, vbox, usrp_rate, demod_rate, audio_rate):

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


        if 1:
            self.src_fft = fftsink2.fft_sink_c(self.panel, title="Data from USRP2",
                                               fft_size=512, sample_rate=usrp_rate,
					       ref_scale=1.0, ref_level=0, y_divs=12)
            self.connect (self.u, self.src_fft)
            vbox.Add (self.src_fft.win, 4, wx.EXPAND)

        if 1:
            post_filt_fft = fftsink2.fft_sink_f(self.panel, title="Post Demod", 
                                                fft_size=1024, sample_rate=usrp_rate,
                                                y_per_div=10, ref_level=0)
            self.connect (self.guts.fm_demod, post_filt_fft)
            vbox.Add (post_filt_fft.win, 4, wx.EXPAND)

        if 0:
            post_deemph_fft = fftsink2.fft_sink_f(self.panel, title="Post Deemph",
                                                  fft_size=512, sample_rate=audio_rate,
                                                  y_per_div=10, ref_level=-20)
            self.connect (self.guts.deemph, post_deemph_fft)
            vbox.Add (post_deemph_fft.win, 4, wx.EXPAND)

        
        # control area form at bottom
        self.myform = myform = form.form()

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)
        myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

        hbox.Add((5,0), 0)
        myform['freq_slider'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
                                        range=(87.9e6, 108.1e6, 0.1e6),
                                        callback=self.set_freq)
        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)

        myform['volume'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
                                        weight=3, range=self.volume_range(),
                                        callback=self.set_vol)
        hbox.Add((5,0), 1)

        myform['gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=self.u.gain_range(),
                                        callback=self.set_gain)
        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        try:
            self.knob = powermate.powermate(self.frame)
            self.rot = 0
            powermate.EVT_POWERMATE_ROTATE (self.frame, self.on_rotate)
            powermate.EVT_POWERMATE_BUTTON (self.frame, self.on_button)
        except:
            pass
Exemple #22
0
	def _build_gui(self, vbox):

		def _form_set_freq(kv):
			# Adjust current SETI frequency, and limits
			self.setifreq_lower = kv['freq'] - (self.seti_freq_range/2)
			self.setifreq_current = kv['freq']
			self.setifreq_upper = kv['freq'] + (self.seti_freq_range/2)

			# Reset SETI analysis timer
			self.seti_then = time.time()
			# Zero-out hits array when changing frequency
			self.hits_array[:,:] = 0.0
			self.hit_intensities[:,:] = -60.0

			return self.set_freq(kv['freq'])

		def _form_set_decln(kv):
			return self.set_decln(kv['decln'])

		# Position the FFT display
		vbox.Add(self.scope.win, 15, wx.EXPAND)

		if self.setimode == False:
			# Position the Total-power stripchart
			vbox.Add(self.chart.win, 15, 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((4,0), 0, 0)

		myform['lmst_high'] = form.static_text_field(
			parent=self.panel, sizer=vbox1, label="Current LMST", weight=1)
		vbox1.Add((4,0), 0, 0)

		if self.setimode == False:
			myform['spec_data'] = form.static_text_field(
				parent=self.panel, sizer=vbox1, label="Spectral Cursor", weight=1)
			vbox1.Add((4,0), 0, 0)

		vbox2 = wx.BoxSizer(wx.VERTICAL)
		if self.setimode == False:
			vbox3 = wx.BoxSizer(wx.VERTICAL)
		g = self.subdev[0].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((4,0), 0, 0)
		if self.setimode == True:
			max_savg = 100
		else:
			max_savg = 3000
		myform['average'] = form.slider_field(parent=self.panel, sizer=vbox2, 
					label="Spectral Averaging (FFT frames)", weight=1, min=1, max=max_savg, callback=self.set_averaging)

		# Set up scan control button when in SETI mode
		if (self.setimode == True):
			# SETI scanning control
			buttonbox = wx.BoxSizer(wx.HORIZONTAL)
			self.scan_control = form.button_with_callback(self.panel,
				  label="Scan: On ",
				  callback=self.toggle_scanning)
	
			buttonbox.Add(self.scan_control, 0, wx.CENTER)
			vbox2.Add(buttonbox, 0, wx.CENTER)

		vbox2.Add((4,0), 0, 0)

		if self.setimode == False:
			myform['integration'] = form.slider_field(parent=self.panel, sizer=vbox2,
				   label="Continuum Integration Time (sec)", weight=1, min=1, max=180, callback=self.set_integration)

			vbox2.Add((4,0), 0, 0)

		myform['decln'] = form.float_field(
			parent=self.panel, sizer=vbox2, label="Current Declination", weight=1,
			callback=myform.check_input_and_call(_form_set_decln))
		vbox2.Add((4,0), 0, 0)

		if self.setimode == False:
			myform['offset'] = form.slider_field(parent=self.panel, sizer=vbox3,
				label="Post-Detector Offset", weight=1, min=-750, max=750, 
				callback=self.set_pd_offset)
			vbox3.Add((2,0), 0, 0)
			myform['dcgain'] = form.slider_field(parent=self.panel, sizer=vbox3,
				label="Post-Detector Gain", weight=1, min=1, max=100, 
				callback=self.set_pd_gain)
			vbox3.Add((2,0), 0, 0)
		hbox.Add(vbox1, 0, 0)
		hbox.Add(vbox2, wx.ALIGN_RIGHT, 0)

		if self.setimode == False:
			hbox.Add(vbox3, wx.ALIGN_RIGHT, 0)

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

		self._build_subpanel(vbox)

		self.lmst_timer = wx.PyTimer(self.lmst_timeout)
		self.other_timer = wx.PyTimer(self.other_timeout)
    def build_gui(self):
        self.myform = myform = form.form()

        # Baseband controls
        bb_sbox = wx.StaticBox(parent=self.panel, label="Baseband Modulation")
        bb_vbox = wx.StaticBoxSizer(
            bb_sbox, wx.VERTICAL)  # Holds all baseband controls as unit

        # First row of baseband controls (modulation type)
        mod_hbox = wx.BoxSizer(wx.HORIZONTAL)
        mod_hbox.Add((10, 0), 0, 0)
        myform['type'] = form.radiobox_field(
            parent=self.panel,
            label="Type",
            sizer=mod_hbox,
            value=None,
            callback=self.evt_set_waveform_type,
            weight=1,
            major_dimension=0,
            choices=usrp2_siggen.waveforms.values())
        bb_vbox.Add((0, 10), 0, 0)
        bb_vbox.Add(mod_hbox, 0, wx.EXPAND)

        # Second row of baseband controls (frequencies)
        bbf_hbox = wx.BoxSizer(wx.HORIZONTAL)
        bbf_hbox.Add((10, 0), 0, 0)
        myform['w1freq'] = form.float_field(
            parent=self.panel,
            sizer=bbf_hbox,
            label="Frequency 1 (Hz)",
            weight=1,
            callback=myform.check_input_and_call(self.evt_set_freq1,
                                                 self.evt_set_status_msg))
        bbf_hbox.Add((10, 0), 0, 0)
        myform['w2freq'] = form.float_field(
            parent=self.panel,
            sizer=bbf_hbox,
            label="Frequency 2 (Hz)",
            weight=1,
            callback=myform.check_input_and_call(self.evt_set_freq2,
                                                 self.evt_set_status_msg))
        bbf_hbox.Add((10, 0), 0, 0)

        bb_vbox.Add((0, 10), 0, 0)
        bb_vbox.Add(bbf_hbox, 0, wx.EXPAND)

        # Add baseband controls to top window sizer
        self.vbox.Add((0, 10), 0, 0)
        self.vbox.Add(bb_vbox, 0, wx.EXPAND)

        # Frequency controls
        fc_sbox = wx.StaticBox(parent=self.panel, label="Center Frequency")
        fc_vbox = wx.StaticBoxSizer(
            fc_sbox, wx.VERTICAL)  # Holds all frequency controls as unit

        # First row of frequency controls (center frequency)
        freq_hbox = wx.BoxSizer(wx.HORIZONTAL)
        freq_hbox.Add((10, 0), 0, 0)
        myform['freq'] = form.float_field(parent=self.panel,
                                          sizer=freq_hbox,
                                          label=None,
                                          weight=1,
                                          callback=myform.check_input_and_call(
                                              self.evt_set_freq,
                                              self.evt_set_status_msg))
        freq_hbox.Add((10, 0), 0, 0)
        myform['freq_slider'] = form.quantized_slider_field(
            parent=self.panel,
            sizer=freq_hbox,
            label="Min-Max",
            weight=4,
            range=(self.min_freq, self.max_freq, self.freq_step),
            callback=self.evt_set_freq)
        freq_hbox.Add((10, 0), 0, 0)

        fc_vbox.Add((10, 0), 0, 0)
        fc_vbox.Add(freq_hbox, 0, wx.EXPAND)

        # Second row of frequency controls (results)
        tr_hbox = wx.BoxSizer(wx.HORIZONTAL)
        tr_hbox.Add((10, 0), 0, 0)
        myform['analog'] = form.static_float_field(parent=self.panel,
                                                   sizer=tr_hbox,
                                                   label="Daughterboard: (Hz)",
                                                   weight=1)
        tr_hbox.Add((10, 0), 0, 0)
        myform['DDC'] = form.static_float_field(parent=self.panel,
                                                sizer=tr_hbox,
                                                label="USRP2 DDC (Hz)",
                                                weight=1)
        tr_hbox.Add((10, 0), 0, 0)
        fc_vbox.Add(tr_hbox, 0, wx.EXPAND)

        # Add frequency controls to top window sizer
        self.vbox.Add((0, 10), 0, 0)
        self.vbox.Add(fc_vbox, 0, wx.EXPAND)

        # Amplitude row
        amp_sbox = wx.StaticBox(parent=self.panel, label="Amplitude")
        amp_hbox = wx.StaticBoxSizer(amp_sbox, wx.HORIZONTAL)
        amp_hbox.Add((10, 0), 0, 0)
        myform['amp'] = form.float_field(parent=self.panel,
                                         sizer=amp_hbox,
                                         label="Linear\n(0.0-1.0)",
                                         weight=1,
                                         callback=myform.check_input_and_call(
                                             self.evt_set_amplitude,
                                             self.evt_set_status_msg))
        amp_hbox.Add((10, 0), 0, 0)
        myform['amp_slider'] = form.quantized_slider_field(
            parent=self.panel,
            sizer=amp_hbox,
            label="dB Full Scale\n(-100-0)",
            weight=4,
            range=(-100.0, 0.0, 1),
            callback=self.evt_set_amplitude)
        amp_hbox.Add((10, 0), 0, 0)
        self.vbox.Add((0, 10), 0, 0)
        self.vbox.Add(amp_hbox, 0, wx.EXPAND)

        # Sample rate row
        sam_sbox = wx.StaticBox(parent=self.panel, label="Sample Rate")
        sam_hbox = wx.StaticBoxSizer(sam_sbox, wx.HORIZONTAL)
        sam_hbox.Add((10, 0), 0, 0)
        myform['interp'] = form.int_field(parent=self.panel,
                                          sizer=sam_hbox,
                                          label="Interpolation",
                                          weight=1,
                                          callback=self.evt_set_interp)
        sam_hbox.Add((10, 0), 0, 0)
        myform['eth'] = form.static_float_field(parent=self.panel,
                                                sizer=sam_hbox,
                                                label="Sample Rate (sps)",
                                                weight=1)
        sam_hbox.Add((10, 0), 0, 0)
        myform['gbe'] = form.static_float_field(parent=self.panel,
                                                sizer=sam_hbox,
                                                label="GbE Rate (bits/sec)",
                                                weight=1)
        sam_hbox.Add((10, 0), 0, 0)
        self.vbox.Add((0, 10), 0, 0)
        self.vbox.Add(sam_hbox, 0, wx.EXPAND)

        # USRP2 row
        u2_sbox = wx.StaticBox(parent=self.panel, label="USRP2 Hardware")
        u2_hbox = wx.StaticBoxSizer(u2_sbox, wx.HORIZONTAL)
        u2_hbox.Add((10, 0), 0, 0)
        myform['ifc'] = form.static_text_field(parent=self.panel,
                                               sizer=u2_hbox,
                                               label="Interface",
                                               weight=2)
        u2_hbox.Add((10, 0), 0, 0)
        myform['mac'] = form.static_text_field(parent=self.panel,
                                               sizer=u2_hbox,
                                               label="MAC Address",
                                               weight=2)
        u2_hbox.Add((10, 0), 0, 0)
        myform['dbid'] = form.static_text_field(parent=self.panel,
                                                sizer=u2_hbox,
                                                label="Daughterboard ID",
                                                weight=1)
        self.vbox.Add((0, 10), 0, 0)
        self.vbox.Add(u2_hbox, 0, wx.EXPAND)
        self.vbox.Add((0, 20), 0, 0)
    def _build_gui(self, vbox, usrp_rate, demod_rate, audio_rate):
        def _form_set_freq(kv):
            return self.set_freq(kv["freq"])

        if 1:
            self.src_fft = fftsink2.fft_sink_c(
                self.panel,
                title="Data from USRP",
                fft_size=512,
                sample_rate=usrp_rate,
                ref_scale=32768.0,
                ref_level=0,
                y_divs=12,
            )
            self.connect(self.u, self.src_fft)
            vbox.Add(self.src_fft.win, 4, wx.EXPAND)

        if 1:
            post_fm_demod_fft = fftsink2.fft_sink_f(
                self.panel, title="Post FM Demod", fft_size=512, sample_rate=demod_rate, y_per_div=10, ref_level=0
            )
            self.connect(self.guts.fm_demod, post_fm_demod_fft)
            vbox.Add(post_fm_demod_fft.win, 4, wx.EXPAND)

        if 0:
            post_stereo_carrier_generator_fft = fftsink2.fft_sink_c(
                self.panel,
                title="Post Stereo_carrier_generator",
                fft_size=512,
                sample_rate=audio_rate,
                y_per_div=10,
                ref_level=0,
            )
            self.connect(self.guts.stereo_carrier_generator, post_stereo_carrier_generator_fft)
            vbox.Add(post_stereo_carrier_generator_fft.win, 4, wx.EXPAND)

        if 0:
            post_deemphasis_left = fftsink2.fft_sink_f(
                self.panel,
                title="Post_Deemphasis_Left",
                fft_size=512,
                sample_rate=audio_rate,
                y_per_div=10,
                ref_level=0,
            )
            self.connect(self.guts.deemph_Left, post_deemphasis_left)
            vbox.Add(post_deemphasis_left.win, 4, wx.EXPAND)

        if 0:
            post_deemphasis_right = fftsink2.fft_sink_f(
                self.panel,
                title="Post_Deemphasis_Right",
                fft_size=512,
                sample_rate=audio_rate,
                y_per_div=10,
                ref_level=-20,
            )
            self.connect(self.guts.deemph_Left, post_deemphasis_right)
            vbox.Add(post_deemphasis_right.win, 4, wx.EXPAND)

        if 0:
            LmR_fft = fftsink2.fft_sink_f(
                self.panel, title="LmR", fft_size=512, sample_rate=audio_rate, y_per_div=10, ref_level=-20
            )
            self.connect(self.guts.LmR_real, LmR_fft)
            vbox.Add(LmR_fft.win, 4, wx.EXPAND)

        if 0:
            self.scope = scopesink2.scope_sink_f(self.panel, sample_rate=demod_rate)
            self.connect(self.guts.fm_demod_a, self.scope)
            vbox.Add(self.scope.win, 4, wx.EXPAND)

        # control area form at bottom
        self.myform = myform = form.form()

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)
        myform["freq"] = form.float_field(
            parent=self.panel,
            sizer=hbox,
            label="Freq",
            weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg),
        )

        hbox.Add((5, 0), 0)
        myform["freq_slider"] = form.quantized_slider_field(
            parent=self.panel, sizer=hbox, weight=3, range=(87.9e6, 108.1e6, 0.1e6), callback=self.set_freq
        )
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)

        myform["volume"] = form.quantized_slider_field(
            parent=self.panel, sizer=hbox, label="Volume", weight=3, range=self.volume_range(), callback=self.set_vol
        )
        hbox.Add((5, 0), 1)

        myform["gain"] = form.quantized_slider_field(
            parent=self.panel,
            sizer=hbox,
            label="Gain",
            weight=3,
            range=self.subdev.gain_range(),
            callback=self.set_gain,
        )
        hbox.Add((5, 0), 0)

        myform["sqlch_thrsh"] = form.quantized_slider_field(
            parent=self.panel,
            sizer=hbox,
            label="Stereo Squelch Threshold",
            weight=3,
            range=(0.0, 1.0, 0.01),
            callback=self.set_squelch,
        )
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        try:
            self.knob = powermate.powermate(self.frame)
            self.rot = 0
            powermate.EVT_POWERMATE_ROTATE(self.frame, self.on_rotate)
            powermate.EVT_POWERMATE_BUTTON(self.frame, self.on_button)
        except:
            print "FYI: No Powermate or Contour Knob found"
Exemple #25
0
    def _build_gui(self, vbox, usrp_rate, demod_rate, audio_rate):

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


        if 0:
            self.src_fft = fftsink2.fft_sink_c(self.panel, title="Data from USRP",
                                               fft_size=512, sample_rate=usrp_rate,
					       ref_scale=32768.0, ref_level=0.0, y_divs=12)
            self.connect (self.u, self.src_fft)
            vbox.Add (self.src_fft.win, 4, wx.EXPAND)

        if 0:
            self.post_filt_fft = fftsink2.fft_sink_c(self.panel, title="Post Channel filter",
                                               fft_size=512, sample_rate=demod_rate)
            self.connect (self.chan_filt, self.post_filt_fft)
            vbox.Add (self.post_filt_fft.win, 4, wx.EXPAND)

        if 0:
            post_demod_fft = fftsink2.fft_sink_f(self.panel, title="Post Demod",
                                                fft_size=1024, sample_rate=demod_rate,
                                                y_per_div=10, ref_level=0)
            self.connect (self.am_demod, post_demod_fft)
            vbox.Add (post_demod_fft.win, 4, wx.EXPAND)

        if 1:
            audio_fft = fftsink2.fft_sink_f(self.panel, title="Audio",
                                                  fft_size=512, sample_rate=audio_rate,
                                                  y_per_div=10, ref_level=20)
            self.connect (self.audio_filt, audio_fft)
            vbox.Add (audio_fft.win, 4, wx.EXPAND)


        # control area form at bottom
        self.myform = myform = form.form()

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)
        myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

        hbox.Add((5,0), 0)
        myform['freq_slider'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
                                        range=(520.0e3, 1611.0e3, 1.0e3),
                                        callback=self.set_freq)
        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)

        myform['volume'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
                                        weight=3, range=self.volume_range(),
                                        callback=self.set_vol)
        hbox.Add((5,0), 1)

        g = self.u.get_gain_range()
        myform['gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=(g.start(), g.stop(), g.step()),
                                        callback=self.set_gain)
        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        try:
            self.knob = powermate.powermate(self.frame)
            self.rot = 0
            powermate.EVT_POWERMATE_ROTATE (self.frame, self.on_rotate)
            powermate.EVT_POWERMATE_BUTTON (self.frame, self.on_button)
        except:
            print "FYI: No Powermate or Contour Knob found"
Exemple #26
0
    def _build_gui(self, vbox, usrp_rate, demod_rate, audio_rate):
        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])

        if 0:
            self.src_fft = fftsink2.fft_sink_c(self.panel,
                                               title="Data from USRP",
                                               fft_size=512,
                                               sample_rate=usrp_rate,
                                               ref_scale=32768.0,
                                               ref_level=0.0,
                                               y_divs=12)
            self.connect(self.u, self.src_fft)
            vbox.Add(self.src_fft.win, 4, wx.EXPAND)

        if 0:
            self.post_filt_fft = fftsink2.fft_sink_c(
                self.panel,
                title="Post Channel filter",
                fft_size=512,
                sample_rate=demod_rate)
            self.connect(self.chan_filt, self.post_filt_fft)
            vbox.Add(self.post_filt_fft.win, 4, wx.EXPAND)

        if 0:
            post_demod_fft = fftsink2.fft_sink_f(self.panel,
                                                 title="Post Demod",
                                                 fft_size=1024,
                                                 sample_rate=demod_rate,
                                                 y_per_div=10,
                                                 ref_level=0)
            self.connect(self.am_demod, post_demod_fft)
            vbox.Add(post_demod_fft.win, 4, wx.EXPAND)

        if 1:
            audio_fft = fftsink2.fft_sink_f(self.panel,
                                            title="Audio",
                                            fft_size=512,
                                            sample_rate=audio_rate,
                                            y_per_div=10,
                                            ref_level=20)
            self.connect(self.audio_filt, audio_fft)
            vbox.Add(audio_fft.win, 4, wx.EXPAND)

        # control area form at bottom
        self.myform = myform = form.form()

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)
        myform['freq'] = form.float_field(parent=self.panel,
                                          sizer=hbox,
                                          label="Freq",
                                          weight=1,
                                          callback=myform.check_input_and_call(
                                              _form_set_freq,
                                              self._set_status_msg))

        hbox.Add((5, 0), 0)
        myform['freq_slider'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
                                        range=(520.0e3, 1611.0e3, 1.0e3),
                                        callback=self.set_freq)
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)

        myform['volume'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
                                        weight=3, range=self.volume_range(),
                                        callback=self.set_vol)
        hbox.Add((5, 0), 1)

        g = self.u.get_gain_range()
        myform['gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=(g.start(), g.stop(), g.step()),
                                        callback=self.set_gain)
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        try:
            self.knob = powermate.powermate(self.frame)
            self.rot = 0
            powermate.EVT_POWERMATE_ROTATE(self.frame, self.on_rotate)
            powermate.EVT_POWERMATE_BUTTON(self.frame, self.on_button)
        except:
            print "FYI: No Powermate or Contour Knob found"
Exemple #27
0
    def _build_gui(self, vbox):
        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])

        self.src_fft = None
        if 1:
            self.src_fft = fftsink2.fft_sink_c(self.panel,
                                               title="Data from MSDD",
                                               fft_size=512,
                                               sample_rate=512)
            #            self.s2f1 = gr.short_to_float()
            #            self.scope = scopesink2.scope_sink_f(self.panel, sample_rate=self.sample_rate*self.fft_size)

            self.connect(self.u, self.src_fft)
            #self.connect (self.s2f1, self.scope)
            vbox.Add(self.src_fft.win, 4, wx.EXPAND)
#
#        if 1:
#            post_filt_fft = fftsink2.fft_sink_f(self.panel, title="Post Demod",
#                                                fft_size=1024, sample_rate=usrp_rate,
#                                                y_per_div=10, ref_level=0)
#            self.connect (self.guts.fm_demod, post_filt_fft)
#            vbox.Add (post_filt_fft.win, 4, wx.EXPAND)
#
#        if 0:
#            post_deemph_fft = fftsink2.fft_sink_f(self.panel, title="Post Deemph",
#                                                  fft_size=512, sample_rate=audio_rate,
#                                                  y_per_div=10, ref_level=-20)
#            self.connect (self.guts.deemph, post_deemph_fft)
#            vbox.Add (post_deemph_fft.win, 4, wx.EXPAND)

# control area form at bottom
        self.myform = myform = form.form()

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)
        myform['freq'] = form.float_field(parent=self.panel,
                                          sizer=hbox,
                                          label="Freq",
                                          weight=1,
                                          callback=myform.check_input_and_call(
                                              _form_set_freq,
                                              self._set_status_msg))

        hbox.Add((5, 0), 0)
        myform['freq_slider'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
                                        range=(30e6, 6e9, 1e6),
                                        callback=self.set_freq)
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)
        #
        #        myform['volume'] = \
        #            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
        #                                        weight=3, range=self.volume_range(),
        #                                        callback=self.set_vol)
        #        hbox.Add((5,0), 1)

        myform['gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=self.gain_range,
                                        callback=self.set_gain)
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)
Exemple #28
0
    def _build_gui(self, vbox, no_gui):

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


        self.src_fft = None
        if 0 and not(no_gui):
            self.src_fft = fftsink2.fft_sink_c(self.panel,
                                               title="Data from USRP",
                                               fft_size=512,
                                               sample_rate=self.rxpath.if_rate,
                                               ref_scale=32768.0,
                                               ref_level=0,
                                               y_per_div=10,
                                               y_divs=12)
            self.connect (self.rxpath.u, self.src_fft)
            vbox.Add (self.src_fft.win, 4, wx.EXPAND)
        if 1 and not(no_gui):
            rx_fft = fftsink2.fft_sink_c(self.panel,
                                         title="Post s/w Resampling",
                                         fft_size=512,
                                         sample_rate=self.rxpath.quad_rate,
                                         ref_level=80,
                                         y_per_div=20)
            self.connect (self.rxpath.resamp, rx_fft)
            vbox.Add (rx_fft.win, 4, wx.EXPAND)
        
        if 1 and not(no_gui):
            post_deemph_fft = fftsink2.fft_sink_f(self.panel,
                                                  title="Post Deemph",
                                                  fft_size=512,
                                                  sample_rate=self.rxpath.audio_rate,
                                                  y_per_div=10,
                                                  ref_level=-40)
            self.connect (self.rxpath.fmrx.deemph, post_deemph_fft)
            vbox.Add (post_deemph_fft.win, 4, wx.EXPAND)

        if 0:
            post_filt_fft = fftsink2.fft_sink_f(self.panel,
                                                title="Post Filter", 
                                                fft_size=512,
                                                sample_rate=audio_rate,
                                                y_per_div=10,
                                                ref_level=-40)
            self.connect (self.guts.audio_filter, post_filt)
            vbox.Add (fft_win4, 4, wx.EXPAND)

        # control area form at bottom
        self.myform = myform = form.form()

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)
        myform['freq'] = form.float_field(
            parent=self.panel, sizer=hbox, label="Freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq,
                                                 self._set_status_msg))

        #hbox.Add((5,0), 0)
        #myform['freq_slider'] = \
        #    form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
        #                                range=(87.9e6, 108.1e6, 0.1e6),
        #                                callback=self.set_freq)

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

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0)

        myform['volume'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
                                        weight=3, range=self.volume_range(),
                                        callback=self.set_volume)
        hbox.Add((5,0), 0)
        myform['squelch'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Squelch",
                                        weight=3, range=self.rxpath.squelch_range(),
                                        callback=self.set_squelch)
        g = self.rxpath.u.get_gain_range()
        hbox.Add((5,0), 0)
        myform['gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=(g.start(), g.stop(), g.step()),
                                        callback=self.set_gain)
        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        try:
            self.knob = powermate.powermate(self.frame)
            self.rot = 0
            powermate.EVT_POWERMATE_ROTATE (self.frame, self.on_rotate)
            powermate.EVT_POWERMATE_BUTTON (self.frame, self.on_button)
        except:
            print "FYI: No Powermate or Contour Knob found"
Exemple #29
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()
Exemple #30
0
    def _build_gui(self, frame, panel, vbox, argv, no_gui):

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

        self.panel = panel

        # FIXME This REALLY needs to be replaced with a hand-crafted button
        # that sends both button down and button up events
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((10,0), 1)
        self.status_msg = wx.StaticText(panel, -1, "Press Space Bar to Transmit")
        of = self.status_msg.GetFont()
        self.status_msg.SetFont(wx.Font(15, of.GetFamily(), of.GetStyle(), of.GetWeight()))
        hbox.Add(self.status_msg, 0, wx.ALIGN_CENTER)
        hbox.Add((10,0), 1)
        vbox.Add(hbox, 0, wx.EXPAND | wx.ALIGN_CENTER)

        panel.Bind(wx.EVT_KEY_DOWN, self._on_key_down)
        panel.Bind(wx.EVT_KEY_UP, self._on_key_up)
        panel.Bind(wx.EVT_KILL_FOCUS, self._on_kill_focus)
        panel.SetFocus()

        if 1 and not(no_gui):
            rx_fft = fftsink2.fft_sink_c(panel, title="Rx Input", fft_size=512,
                                         sample_rate=self.rxpath.if_rate,
                                         ref_level=80, y_per_div=20)
            self.connect (self.rxpath.u, rx_fft)
            vbox.Add (rx_fft.win, 1, wx.EXPAND)

        if 1 and not(no_gui):
            rx_fft = fftsink2.fft_sink_c(panel, title="Post s/w Resampler",
                                         fft_size=512, sample_rate=self.rxpath.quad_rate,
                                         ref_level=80, y_per_div=20)
            self.connect (self.rxpath.resamp, rx_fft)
            vbox.Add (rx_fft.win, 1, wx.EXPAND)

        if 0 and not(no_gui):
            foo = scopesink2.scope_sink_f(panel, title="Squelch",
                                    	  sample_rate=32000)
            self.connect (self.rxpath.fmrx.div, (foo,0))
            self.connect (self.rxpath.fmrx.gate, (foo,1))
            self.connect (self.rxpath.fmrx.squelch_lpf, (foo,2))
            vbox.Add (foo.win, 1, wx.EXPAND)

        if 0 and not(no_gui):
            tx_fft = fftsink2.fft_sink_c(panel, title="Tx Output",
                                         fft_size=512, sample_rate=self.txpath.usrp_rate)
            self.connect (self.txpath.amp, tx_fft)
            vbox.Add (tx_fft.win, 1, wx.EXPAND)


        # add control area at the bottom

        self.myform = myform = form.form()

        # first row
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0, 0)
        myform['freq'] = form.float_field(
            parent=panel, sizer=hbox, label="Freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

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


        # second row
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        myform['volume'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
                                        weight=3, range=self.rxpath.volume_range(),
                                        callback=self.set_volume)
        hbox.Add((5,0), 0)
        myform['squelch'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Squelch",
                                        weight=3, range=self.rxpath.squelch_range(),
                                        callback=self.set_squelch)

        g = self.rxpath.u.get_gain_range()
        hbox.Add((5,0), 0)
        myform['rx_gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Rx Gain",
                                        weight=3, range=(g.start(), g.stop(), g.step()),
                                        callback=self.set_rx_gain)
        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)


        self._build_subpanel(vbox)
Exemple #31
0
    def _build_gui(self, vbox, no_gui):
        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])

        self.src_fft = None
        if 1 and not (no_gui):
            self.src_fft = fftsink2.fft_sink_c(self.panel,
                                               title="Data from USRP",
                                               fft_size=512,
                                               sample_rate=self.rxpath.if_rate,
                                               ref_scale=32768.0,
                                               ref_level=0,
                                               y_per_div=10,
                                               y_divs=12)
            self.connect(self.rxpath.u, self.src_fft)
            vbox.Add(self.src_fft.win, 4, wx.EXPAND)
        if 1 and not (no_gui):
            rx_fft = fftsink2.fft_sink_c(self.panel,
                                         title="Post s/w DDC",
                                         fft_size=512,
                                         sample_rate=self.rxpath.quad_rate,
                                         ref_level=80,
                                         y_per_div=20)
            self.connect(self.rxpath.ddc, rx_fft)
            vbox.Add(rx_fft.win, 4, wx.EXPAND)

        if 1 and not (no_gui):
            post_deemph_fft = fftsink2.fft_sink_f(
                self.panel,
                title="Post Deemph",
                fft_size=512,
                sample_rate=self.rxpath.audio_rate,
                y_per_div=10,
                ref_level=-40)
            self.connect(self.rxpath.fmrx.deemph, post_deemph_fft)
            vbox.Add(post_deemph_fft.win, 4, wx.EXPAND)

        if 0:
            post_filt_fft = fftsink2.fft_sink_f(self.panel,
                                                title="Post Filter",
                                                fft_size=512,
                                                sample_rate=audio_rate,
                                                y_per_div=10,
                                                ref_level=-40)
            self.connect(self.guts.audio_filter, post_filt)
            vbox.Add(fft_win4, 4, wx.EXPAND)

        # control area form at bottom
        self.myform = myform = form.form()

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)
        myform['freq'] = form.float_field(parent=self.panel,
                                          sizer=hbox,
                                          label="Freq",
                                          weight=1,
                                          callback=myform.check_input_and_call(
                                              _form_set_freq,
                                              self._set_status_msg))

        #hbox.Add((5,0), 0)
        #myform['freq_slider'] = \
        #    form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
        #                                range=(87.9e6, 108.1e6, 0.1e6),
        #                                callback=self.set_freq)

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

        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5, 0), 0)

        myform['volume'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
                                        weight=3, range=self.volume_range(),
                                        callback=self.set_volume)
        hbox.Add((5, 0), 0)
        myform['squelch'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Squelch",
                                        weight=3, range=self.rxpath.squelch_range(),
                                        callback=self.set_squelch)
        hbox.Add((5, 0), 0)
        myform['gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
                                        weight=3, range=self.rxpath.subdev.gain_range(),
                                        callback=self.set_gain)
        hbox.Add((5, 0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)

        try:
            self.knob = powermate.powermate(self.frame)
            self.rot = 0
            powermate.EVT_POWERMATE_ROTATE(self.frame, self.on_rotate)
            powermate.EVT_POWERMATE_BUTTON(self.frame, self.on_button)
        except:
            print "FYI: No Powermate or Contour Knob found"
Exemple #32
0
    def _build_gui(self, frame, panel, vbox, argv, no_gui):

        def _form_set_freq(kv):
            return self.set_freq(kv['freq'])
            
        self.panel = panel
        
        # FIXME This REALLY needs to be replaced with a hand-crafted button
        # that sends both button down and button up events
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((10,0), 1)
        self.status_msg = wx.StaticText(panel, -1, "Press Space Bar to Transmit")
        of = self.status_msg.GetFont()
        self.status_msg.SetFont(wx.Font(15, of.GetFamily(), of.GetStyle(), of.GetWeight()))
        hbox.Add(self.status_msg, 0, wx.ALIGN_CENTER)
        hbox.Add((10,0), 1)
        vbox.Add(hbox, 0, wx.EXPAND | wx.ALIGN_CENTER)

        panel.Bind(wx.EVT_KEY_DOWN, self._on_key_down)
        panel.Bind(wx.EVT_KEY_UP, self._on_key_up)
        panel.Bind(wx.EVT_KILL_FOCUS, self._on_kill_focus)
        panel.SetFocus()

        if 1 and not(no_gui):
            rx_fft = fftsink2.fft_sink_c(panel, title="Rx Input", fft_size=512,
                                         sample_rate=self.rxpath.if_rate,
                                         ref_level=80, y_per_div=20)
            self.connect (self.rxpath.u, rx_fft)
            vbox.Add (rx_fft.win, 1, wx.EXPAND)

        if 1 and not(no_gui):
            rx_fft = fftsink2.fft_sink_c(panel, title="Post s/w DDC",
                                         fft_size=512, sample_rate=self.rxpath.quad_rate,
                                         ref_level=80, y_per_div=20)
            self.connect (self.rxpath.ddc, rx_fft)
            vbox.Add (rx_fft.win, 1, wx.EXPAND)

        if 0 and not(no_gui):
            foo = scopesink2.scope_sink_f(panel, title="Squelch",
                                    	  sample_rate=32000)
            self.connect (self.rxpath.fmrx.div, (foo,0))
            self.connect (self.rxpath.fmrx.gate, (foo,1))
            self.connect (self.rxpath.fmrx.squelch_lpf, (foo,2))
            vbox.Add (foo.win, 1, wx.EXPAND)

        if 0 and not(no_gui):
            tx_fft = fftsink2.fft_sink_c(panel, title="Tx Output",
                                         fft_size=512, sample_rate=self.txpath.usrp_rate)
            self.connect (self.txpath.amp, tx_fft)
            vbox.Add (tx_fft.win, 1, wx.EXPAND)


        # add control area at the bottom

        self.myform = myform = form.form()

        # first row
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add((5,0), 0, 0)
        myform['freq'] = form.float_field(
            parent=panel, sizer=hbox, label="Freq", weight=1,
            callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))

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


        # second row
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        myform['volume'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Volume",
                                        weight=3, range=self.rxpath.volume_range(),
                                        callback=self.set_volume)
        hbox.Add((5,0), 0)
        myform['squelch'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Squelch",
                                        weight=3, range=self.rxpath.squelch_range(),
                                        callback=self.set_squelch)
        hbox.Add((5,0), 0)
        myform['rx_gain'] = \
            form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Rx Gain",
                                        weight=3, range=self.rxpath.subdev.gain_range(),
                                        callback=self.set_rx_gain)
        hbox.Add((5,0), 0)
        vbox.Add(hbox, 0, wx.EXPAND)


        self._build_subpanel(vbox)
Exemple #33
0
    def build_gui(self):
        self.myform = myform = form.form()

        # Baseband controls
        bb_sbox = wx.StaticBox(parent=self.panel, label="Baseband Modulation")
        bb_vbox = wx.StaticBoxSizer(bb_sbox, wx.VERTICAL) # Holds all baseband controls as unit

        # First row of baseband controls (modulation type)
        mod_hbox = wx.BoxSizer(wx.HORIZONTAL)
        mod_hbox.Add((10,0), 0, 0)
        myform['type'] = form.radiobox_field(
            parent=self.panel, label="Type", sizer=mod_hbox, value=None,
            callback=self.evt_set_waveform_type, weight=1, major_dimension=0,
            choices=usrp2_siggen.waveforms.values() )
        bb_vbox.Add((0,10), 0, 0)
        bb_vbox.Add(mod_hbox, 0, wx.EXPAND)

        # Second row of baseband controls (frequencies)
        bbf_hbox = wx.BoxSizer(wx.HORIZONTAL)
        bbf_hbox.Add((10,0), 0, 0)
        myform['w1freq'] = form.float_field(
            parent=self.panel, sizer=bbf_hbox, label="Frequency 1 (Hz)", weight=1,
            callback=myform.check_input_and_call(self.evt_set_freq1, self.evt_set_status_msg) )
        bbf_hbox.Add((10,0), 0, 0)
        myform['w2freq'] = form.float_field(
            parent=self.panel, sizer=bbf_hbox, label="Frequency 2 (Hz)", weight=1,
            callback=myform.check_input_and_call(self.evt_set_freq2, self.evt_set_status_msg) )
        bbf_hbox.Add((10,0), 0, 0)
        
        bb_vbox.Add((0,10), 0, 0)
        bb_vbox.Add(bbf_hbox, 0, wx.EXPAND)

        # Add baseband controls to top window sizer
        self.vbox.Add((0,10), 0, 0)
        self.vbox.Add(bb_vbox, 0, wx.EXPAND)

        # Frequency controls
        fc_sbox = wx.StaticBox(parent=self.panel, label="Center Frequency")
        fc_vbox = wx.StaticBoxSizer(fc_sbox, wx.VERTICAL) # Holds all frequency controls as unit

        # First row of frequency controls (center frequency)
        freq_hbox = wx.BoxSizer(wx.HORIZONTAL)
        freq_hbox.Add((10,0), 0, 0)
        myform['freq'] = form.float_field(
            parent=self.panel, sizer=freq_hbox, label=None, weight=1,
            callback=myform.check_input_and_call(self.evt_set_freq, self.evt_set_status_msg) )
        freq_hbox.Add((10,0), 0, 0)
        myform['freq_slider'] = form.quantized_slider_field(
            parent=self.panel, sizer=freq_hbox, label="Min-Max", weight=4,
            range = (self.min_freq, self.max_freq, self.freq_step),
            callback=self.evt_set_freq)
        freq_hbox.Add((10,0), 0, 0)

        fc_vbox.Add((10,0), 0, 0)
        fc_vbox.Add(freq_hbox, 0, wx.EXPAND)

        # Second row of frequency controls (results)
        tr_hbox = wx.BoxSizer(wx.HORIZONTAL)
        tr_hbox.Add((10,0), 0, 0)
        myform['analog'] = form.static_float_field(
            parent=self.panel, sizer=tr_hbox, label="Daughterboard: (Hz)", weight=1)
        tr_hbox.Add((10,0), 0, 0)
        myform['DDC'] = form.static_float_field(
            parent=self.panel, sizer=tr_hbox, label="USRP2 DDC (Hz)", weight=1)
        tr_hbox.Add((10,0), 0, 0)
        fc_vbox.Add(tr_hbox, 0, wx.EXPAND)

        # Add frequency controls to top window sizer
        self.vbox.Add((0,10), 0, 0)
        self.vbox.Add(fc_vbox, 0, wx.EXPAND)

        # Amplitude row
        amp_sbox = wx.StaticBox(parent=self.panel, label="Amplitude")
        amp_hbox = wx.StaticBoxSizer(amp_sbox, wx.HORIZONTAL)
        amp_hbox.Add((10,0), 0, 0)
        myform['amp'] = form.float_field(
            parent=self.panel, sizer=amp_hbox, label="Linear\n(0.0-1.0)", weight=1,
            callback=myform.check_input_and_call(self.evt_set_amplitude, self.evt_set_status_msg) )
        amp_hbox.Add((10,0), 0, 0)
        myform['amp_slider'] = form.quantized_slider_field(
            parent=self.panel, sizer=amp_hbox, label="dB Full Scale\n(-100-0)", weight=4,
            range=(-100.0, 0.0, 1), callback=self.evt_set_amplitude)
        amp_hbox.Add((10,0), 0, 0)
        self.vbox.Add((0,10), 0, 0)
        self.vbox.Add(amp_hbox, 0, wx.EXPAND)

        # Sample rate row
        sam_sbox = wx.StaticBox(parent=self.panel, label="Sample Rate")
        sam_hbox = wx.StaticBoxSizer(sam_sbox, wx.HORIZONTAL)
        sam_hbox.Add((10,0), 0, 0)
        myform['interp'] = form.int_field(
            parent=self.panel, sizer=sam_hbox, label="Interpolation", weight=1,
            callback=self.evt_set_interp)
        sam_hbox.Add((10,0), 0, 0)
        myform['eth'] = form.static_float_field(
            parent=self.panel, sizer=sam_hbox, label="Sample Rate (sps)", weight=1)
        sam_hbox.Add((10,0), 0, 0)
        myform['gbe'] = form.static_float_field(
            parent=self.panel, sizer=sam_hbox, label="GbE Rate (bits/sec)", weight=1)
        sam_hbox.Add((10,0), 0, 0)
        self.vbox.Add((0,10), 0, 0)
        self.vbox.Add(sam_hbox, 0, wx.EXPAND)

        # USRP2 row
        u2_sbox = wx.StaticBox(parent=self.panel, label="USRP2 Hardware")
        u2_hbox = wx.StaticBoxSizer(u2_sbox, wx.HORIZONTAL)
        u2_hbox.Add((10,0), 0, 0)
        myform['ifc'] = form.static_text_field(parent=self.panel, sizer=u2_hbox, 
                                               label="Interface", weight=2)
        u2_hbox.Add((10,0), 0, 0)
        myform['mac'] = form.static_text_field(parent=self.panel, sizer=u2_hbox, 
                                               label="MAC Address", weight=2)
        u2_hbox.Add((10,0), 0, 0)
        myform['dbid'] = form.static_text_field(parent=self.panel, sizer=u2_hbox, 
                                                label="Daughterboard ID", weight=1)
        self.vbox.Add((0,10), 0, 0)
        self.vbox.Add(u2_hbox, 0, wx.EXPAND)
        self.vbox.Add((0,20), 0, 0)