[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Commit-gnuradio] r10476 - gnuradio/trunk/gr-utils/src/python
|
From: |
jcorgan |
|
Subject: |
[Commit-gnuradio] r10476 - gnuradio/trunk/gr-utils/src/python |
|
Date: |
Sun, 22 Feb 2009 13:55:29 -0700 (MST) |
Author: jcorgan
Date: 2009-02-22 13:55:28 -0700 (Sun, 22 Feb 2009)
New Revision: 10476
Added:
gnuradio/trunk/gr-utils/src/python/usrp2_siggen_gui.py
Modified:
gnuradio/trunk/gr-utils/src/python/Makefile.am
gnuradio/trunk/gr-utils/src/python/usrp2_siggen.py
Log:
Re-implementation of usrp2_siggen.py with dynamically adjustable flowgraph.
Adds new usrp2_siggen_gui.py that implements GUI interface on top if same,
GUI-unaware flowgraph. Uses new gr.wxgui.gui class.
Modified: gnuradio/trunk/gr-utils/src/python/Makefile.am
===================================================================
--- gnuradio/trunk/gr-utils/src/python/Makefile.am 2009-02-22 20:52:29 UTC
(rev 10475)
+++ gnuradio/trunk/gr-utils/src/python/Makefile.am 2009-02-22 20:55:28 UTC
(rev 10476)
@@ -54,6 +54,7 @@
usrp_test_loopback.py \
usrp2_fft.py \
usrp2_rx_cfile.py \
- usrp2_siggen.py
-
+ usrp2_siggen.py \
+ usrp2_siggen_gui.py
+
MOSTLYCLEANFILES = *~ *.pyc
Modified: gnuradio/trunk/gr-utils/src/python/usrp2_siggen.py
===================================================================
--- gnuradio/trunk/gr-utils/src/python/usrp2_siggen.py 2009-02-22 20:52:29 UTC
(rev 10475)
+++ gnuradio/trunk/gr-utils/src/python/usrp2_siggen.py 2009-02-22 20:55:28 UTC
(rev 10476)
@@ -20,8 +20,7 @@
# Boston, MA 02110-1301, USA.
#
-from gnuradio import gr, eng_notation
-from gnuradio import usrp2
+from gnuradio import gr, eng_notation, usrp2
from gnuradio.eng_option import eng_option
from optparse import OptionParser
import sys
@@ -29,165 +28,369 @@
n2s = eng_notation.num_to_str
-class siggen_top_block(gr.top_block):
- def __init__(self, options):
+waveforms = { gr.GR_SIN_WAVE : "Complex Sinusoid",
+ gr.GR_CONST_WAVE : "Constant",
+ gr.GR_GAUSSIAN : "Gaussian Noise",
+ gr.GR_UNIFORM : "Uniform Noise",
+ "2tone" : "Two Tone",
+ "sweep" : "Sweep" }
+
+#
+# GUI-unaware GNU Radio flowgraph. This may be used either with command
+# line applications or GUI applications.
+#
+class top_block(gr.top_block):
+ def __init__(self, options, args):
gr.top_block.__init__(self)
+ self._verbose = options.verbose
- # Create a USRP2 sink with the requested interpolation rate
- self._u = usrp2.sink_32fc(options.interface, options.mac_addr)
- self._u.set_interp(options.interp)
+ self._interp = 0
+ self._gain = 0
+ self._freq = None # Indicates frequency hasn't been successfully
set yet
+ self._bb_freq = 0
+ self._ddc_freq = 0
+ self._amplitude = 0
+ self._type = None # Indicates waveform flowgraph not created yet
+ self._offset = options.offset
- # Set the Tx daughterboard gain as requested
- if options.gain is None:
+ self.set_usrp2(options.interface, options.mac_addr)
+ self.set_interp(options.interp)
+ self.set_gain(options.gain)
+ self.set_freq(options.tx_freq, options.lo_offset)
+ self.set_amplitude(options.amplitude)
+
+ self.set_waveform_freq(options.waveform_freq)
+ #self.set_waveform2_freq(options.waveform2_freq)
+ self._waveform2_freq = options.waveform2_freq
+ self.set_waveform(options.type)
+
+ def set_usrp2(self, interface, mac_addr):
+ self._u = usrp2.sink_32fc(interface, mac_addr)
+ self._dac_rate = self._u.dac_rate()
+ if self._verbose:
+ print "Network interface:", interface
+ print "Network address:", self._u.mac_addr()
+ print "Daughterboard ID:", hex(self._u.daughterboard_id())
+
+ def set_interp(self, interp):
+ if interp < 4 or interp > 512: # FIXME get from flowgraph
+ if self._verbose: print "Interpolation rate out of range:", interp
+ return False
+
+ if not self._u.set_interp(interp):
+ raise RuntimeError("Failed to set interpolation rate %i" %
(interp,))
+
+ self._interp = interp
+ self._eth_rate = self._dac_rate/self._interp
+ if self._verbose:
+ print "USRP2 interpolation rate:", self._interp
+ print "USRP2 IF bandwidth: %sHz" % (n2s(self._eth_rate),)
+
+ if (self._type == gr.GR_SIN_WAVE or
+ self._type == gr.GR_CONST_WAVE):
+ self._src.set_sampling_freq(self._eth_rate)
+ elif self._type == "2tone":
+ self._src1.set_sampling_freq(self._eth_rate)
+ self._src1.set_sampling_freq(self._eth_rate)
+ elif self._type == "sweep":
+ self._src1.set_sampling_freq(self._eth_rate)
+
self._src1.set_sampling_freq(self._waveform_freq*2*math.pi/self._eth_rate)
+ else:
+ return True # Waveform not yet set
+
+ if self._verbose: print "Set interpolation rate to:", interp
+ return True
+
+ def set_gain(self, gain):
+ if gain is None:
g = self._u.gain_range()
- options.gain = float(g[0]+g[1])/2
- self._u.set_gain(options.gain)
+ gain = float(g[0]+g[1])/2
+ if self._verbose:
+ print "Using auto-calculated mid-point TX gain"
+ self._u.set_gain(gain)
+ self._gain = gain
+ if self._verbose:
+ print "Set TX gain to:", self._gain
- # Tune the USRP2 FPGA and daughterboard to the requested center
frequency
- # and LO offset
- if options.lo_offset is not None:
- self._u.set_lo_offset(options.lo_offset)
+ def set_freq(self, target_freq, lo_offset=None):
+ if lo_offset is not None:
+ self._lo_offset = lo_offset
+ self._u.set_lo_offset(self._lo_offset)
+ if self._verbose:
+ print "Set LO offset frequency to: %sHz" % (n2s(lo_offset),)
- tr = self._u.set_center_freq(options.tx_freq)
- if tr == None:
- sys.stderr.write('Failed to set center frequency\n')
- raise SystemExit, 1
+ if target_freq is None:
+ f = self._u.freq_range()
+ target_freq = float(f[0]+f[1])/2.0
+ if self._verbose:
+ print "Using auto-calculated mid-point frequency"
- eth_rate = self._u.dac_rate()/self._u.interp()
+ tr = self._u.set_center_freq(target_freq)
+ fs = "%sHz" % (n2s(target_freq),)
+ if tr is not None:
+ self._freq = target_freq
+
+ else:
+ return True # Waveform not yet set
- # Create a source for the requested waveform type
- if options.type == gr.GR_SIN_WAVE or options.type == gr.GR_CONST_WAVE:
- self._src = gr.sig_source_c(eth_rate, # Sample rate
- options.type, # Waveform type
- options.waveform_freq, # Waveform
frequency
- options.amplitude, # Waveform
amplitude
- options.offset) # Waveform
offset
-
- elif options.type == gr.GR_GAUSSIAN or options.type == gr.GR_UNIFORM:
- self._src = gr.noise_source_c(options.type, options.amplitude)
- elif options.type == "2tone":
- self._src1 = gr.sig_source_c(eth_rate,
+ if self._verbose: print "Set amplitude to:", amplitude
+ return True
+
+ def set_gain(self, gain):
+ if gain is None:
+ g = self._u.gain_range()
+ gain = float(g[0]+g[1])/2
+ if self._verbose:
+ print "Using auto-calculated mid-point TX gain"
+ self._u.set_gain(gain)
+ self._gain = gain
+ if self._verbose:
+ print "Set TX gain to:", self._gain
+
+ def set_freq(self, target_freq, lo_offset=None):
+ if lo_offset is not None:
+ self._lo_offset = lo_offset
+ self._u.set_lo_offset(self._lo_offset)
+ if self._verbose:
+ print "Set LO offset frequency to: %sHz" % (n2s(lo_offset),)
+
+ if target_freq is None:
+ f = self._u.freq_range()
+ target_freq = float(f[0]+f[1])/2.0
+ if self._verbose:
+ print "Using auto-calculated mid-point frequency"
+
+ tr = self._u.set_center_freq(target_freq)
+ fs = "%sHz" % (n2s(target_freq),)
+ if tr is not None:
+ self._freq = target_freq
+ self._ddc_freq = tr.dxc_freq
+ self._bb_freq = tr.baseband_freq
+ if self._verbose:
+ print "Set center frequency to", fs
+ print "Tx baseband frequency: %sHz" % (n2s(tr.baseband_freq),)
+ print "Tx DDC frequency: %sHz" % (n2s(tr.dxc_freq),)
+ print "Tx residual frequency: %sHz" % (n2s(tr.residual_freq),)
+
+ return tr
+
+ def set_waveform_freq(self, freq):
+ self._waveform_freq = freq
+ if self._type == gr.GR_SIN_WAVE:
+ self._src.set_frequency(freq)
+ elif self._type == "2tone" or self._type == "sweep":
+ self._src1.set_frequency(freq)
+ return True
+
+ def set_waveform2_freq(self, freq):
+ self._waveform2_freq = freq
+ if self._type == "2tone":
+ self._src2.set_frequency(freq)
+ elif self._type == "sweep":
+ self._src1.set_frequency(freq)
+ return True
+
+ def set_waveform(self, type):
+ self.lock()
+ self.disconnect_all()
+
+ if type == gr.GR_SIN_WAVE or type == gr.GR_CONST_WAVE:
+ self._src = gr.sig_source_c(self._eth_rate, # Sample rate
+ type, # Waveform type
+ self._waveform_freq, # Waveform
frequency
+ self._amplitude, # Waveform
amplitude
+ self._offset) # Waveform offset
+ elif type == gr.GR_GAUSSIAN or type == gr.GR_UNIFORM:
+ self._src = gr.noise_source_c(type, self._amplitude)
+ elif type == "2tone":
+ self._src1 = gr.sig_source_c(self._eth_rate,
gr.GR_SIN_WAVE,
- options.waveform_freq,
- options.amplitude,
+ self._waveform_freq,
+ self._amplitude/2.0,
0)
- if(options.waveform2_freq is None):
- w2freq = -options.waveform_freq
- else:
- w2freq = options.waveform2_freq
- self._src2 = gr.sig_source_c(eth_rate,
+ if(self._waveform2_freq is None):
+ self._waveform2_freq = -self._waveform_freq
+
+ self._src2 = gr.sig_source_c(self._eth_rate,
gr.GR_SIN_WAVE,
- w2freq,
- options.amplitude,
+ self._waveform2_freq,
+ self._amplitude/2.0,
0)
self._src = gr.add_cc()
self.connect(self._src1,(self._src,0))
self.connect(self._src2,(self._src,1))
- elif options.type == "sweep":
+ elif type == "sweep":
# rf freq is center frequency
# waveform_freq is total swept width
# waveform2_freq is sweep rate
- # will sweep from (rf_freq-waveform_freq/2) to
(rf_freq+waveform_freq/2)
- self._src1 = gr.sig_source_f(eth_rate,
+ # will sweep from (rf_freq-waveform_freq/2) to
(rf_freq+waveform_freq/2)
+ if self._waveform2_freq is None:
+ self._waveform2_freq = 0.1
+
+ self._src1 = gr.sig_source_f(self._eth_rate,
gr.GR_TRI_WAVE,
- options.waveform2_freq,
- 1.0, # options.waveform_freq,
+ self._waveform2_freq,
+ 1.0,
-0.5)
- self._src2 =
gr.frequency_modulator_fc(options.waveform_freq*2*math.pi/eth_rate)
- self._src = gr.multiply_const_cc(options.amplitude)
+ self._src2 =
gr.frequency_modulator_fc(self._waveform_freq*2*math.pi/self._eth_rate)
+ self._src = gr.multiply_const_cc(self._amplitude)
self.connect(self._src1,self._src2,self._src)
else:
- sys.stderr.write('Unknown waveform type\n')
- raise SystemExit, 1
+ raise RuntimeError("Unknown waveform type")
- if options.verbose:
- print "Network interface:", options.interface
- print "USRP2 address:", self._u.mac_addr()
- #print "Using TX d'board %s" % (self._u.tx_name(),)
- print "Tx gain:", options.gain
- print "Tx baseband frequency:", n2s(tr.baseband_freq), "Hz"
- print "Tx DDC frequency:", n2s(tr.dxc_freq), "Hz"
- print "Tx residual frequency:", n2s(tr.residual_freq), "Hz"
- print "Tx interpolation rate:", options.interp
- print "Tx GbE sample rate:", n2s(eth_rate), "samples/sec"
- if options.type == gr.GR_SIN_WAVE:
- print "Baseband waveform type: Sine wave"
- print "Baseband waveform frequency:",
n2s(options.waveform_freq), "Hz"
- elif options.type == gr.GR_CONST_WAVE:
- print "Baseband waveform type: Constant"
- elif options.type == gr.GR_GAUSSIAN:
- print "Baseband waveform type: Gaussian noise"
- elif options.type == gr.GR_UNIFORM:
- print "Baseband waveform type: Uniform noise"
-
- # Wire the flowgraph
self.connect(self._src, self._u)
-
+ self._type = type
+ self.unlock()
+
+ if self._verbose:
+ print "Set baseband modulation to:", waveforms[self._type]
+ if type == gr.GR_SIN_WAVE:
+ print "Modulation frequency: %sHz" %
(n2s(self._waveform_freq),)
+ print "Initial phase:", self._offset
+ elif type == "2tone":
+ print "Tone 1: %sHz" % (n2s(self._waveform_freq),)
+ print "Tone 2: %sHz" % (n2s(self._waveform2_freq),)
+ elif type == "sweep":
+ print "Sweeping across %sHz to %sHz" %
(n2s(-self._waveform_freq/2.0),n2s(self._waveform_freq/2.0))
+ print "Sweep rate: %sHz" % (n2s(self._waveform2_freq),)
+ print "TX amplitude:", self._amplitude
+
+
+ def set_amplitude(self, amplitude):
+ if amplitude < 0.0 or amplitude > 1.0:
+ if self._verbose: print "Amplitude out of range:", amplitude
+ return False
+
+ self._amplitude = amplitude
+
+ if (self._type == gr.GR_SIN_WAVE or
+ self._type == gr.GR_CONST_WAVE or
+ self._type == gr.GR_GAUSSIAN or
+ self._type == gr.GR_UNIFORM):
+ self._src.set_amplitude(amplitude)
+ elif self._type == "2tone":
+ self._src1.set_amplitude(amplitude/2.0)
+ self._src2.set_amplitude(amplitude/2.0)
+ elif self._type == "sweep":
+ self._src.set_k(amplitude)
+ else:
+ return True # Waveform not yet set
+
+ if self._verbose: print "Set amplitude to:", amplitude
+ return True
+
+
+ # Property getters
+
+ #def interface(self):
+ # return self._u.ifc_name()
+
+ def mac_addr(self):
+ return self._u.mac_addr()
+
+ def ifc_name(self):
+ return self._u.ifc_name()
+
+ def daughterboard_id(self):
+ return self._u.daughterboard_id()
+
+ def interp_rate(self):
+ return self._interp
+
+ def eth_rate(self):
+ return self._eth_rate
+
+ def freq(self):
+ return self._freq
+
+ def freq_range(self):
+ fr = self._u.freq_range()
+ if self._u.daughterboard_id() == 0x0000:
+ fr = (-50e6, 50e6) # DEBUG
+ return fr
+
+ def ddc_freq(self):
+ return self._ddc_freq
+
+ def baseband_freq(self):
+ return self._bb_freq
+
+ def amplitude(self):
+ return self._amplitude
+
+ def waveform_type(self):
+ return self._type
+
+ def waveform_freq(self):
+ return self._waveform_freq
+
+ def waveform2_freq(self):
+ if self._waveform2_freq is None:
+ return -self._waveform_freq
+ else:
+ return self._waveform2_freq
+
def get_options():
usage="%prog: [options]"
parser = OptionParser(option_class=eng_option, usage=usage)
+
parser.add_option("-e", "--interface", type="string", default="eth0",
- help="use specified Ethernet interface
[default=%default]")
+ help="Use specified Ethernet interface
[default=%default]")
parser.add_option("-m", "--mac-addr", type="string", default="",
- help="use USRP2 at specified MAC address
[default=None]")
- parser.add_option("-i", "--interp", type="int", default=16,
- help="set fgpa decimation rate to DECIM
[default=%default]")
+ help="Use USRP2 at specified MAC address
[default=None]")
+ parser.add_option("-i", "--interp", type="int", default=16,
metavar="INTERP",
+ help="Set FPGA interpolation rate of INTERP
[default=%default]")
+ parser.add_option("-f", "--tx-freq", type="eng_float", default=None,
+ help="Set carrier frequency to FREQ
[default=mid-point]", metavar="FREQ")
+ parser.add_option("--lo-offset", type="eng_float", default=None,
+ help="set daughterboard LO offset to OFFSET [default=hw
default]")
parser.add_option("-g", "--gain", type="eng_float", default=None,
- help="set output gain to GAIN [default=%default]")
- parser.add_option("-f", "--tx-freq", type="eng_float", default=None,
- help="set frequency to FREQ", metavar="FREQ")
- parser.add_option("-v", "--verbose", action="store_true", default=False,
- help="verbose output")
+ help="Set TX gain to GAIN [default=mid-point]")
parser.add_option("-w", "--waveform-freq", type="eng_float", default=0,
- help="set waveform frequency to FREQ [default=%default]")
+ help="Set baseband waveform frequency to FREQ
[default=%default]")
parser.add_option("-x", "--waveform2-freq", type="eng_float", default=None,
- help="set waveform frequency to FREQ [default=%default]")
- parser.add_option("-a", "--amplitude", type="eng_float", default=0.5,
- help="set waveform amplitude to AMPLITUDE (0-1.0)
[default=%default]", metavar="AMPL")
- parser.add_option("--offset", type="eng_float", default=0,
- help="set waveform offset to OFFSET [default=%default]")
- parser.add_option("--lo-offset", type="eng_float", default=None,
- help="set daughterboard LO offset to OFFSET [default=hw
default]")
+ help="Set 2nd waveform frequency to FREQ
[default=%default]")
parser.add_option("--sine", dest="type", action="store_const",
const=gr.GR_SIN_WAVE,
- help="generate a complex sinusoid [default]",
default=gr.GR_SIN_WAVE)
+ help="Generate a carrier modulated by a complex sine
wave", default=gr.GR_SIN_WAVE)
parser.add_option("--const", dest="type", action="store_const",
const=gr.GR_CONST_WAVE,
- help="generate a constant output")
+ help="Generate a constant carrier")
+ parser.add_option("--offset", type="eng_float", default=0,
+ help="Set waveform phase offset to OFFSET
[default=%default]")
parser.add_option("--gaussian", dest="type", action="store_const",
const=gr.GR_GAUSSIAN,
- help="generate Gaussian random output")
+ help="Generate Gaussian random output")
parser.add_option("--uniform", dest="type", action="store_const",
const=gr.GR_UNIFORM,
- help="generate Uniform random output")
+ help="Generate Uniform random output")
parser.add_option("--2tone", dest="type", action="store_const",
const="2tone",
- help="generate Two Tone signal for IMD testing")
+ help="Generate Two Tone signal for IMD testing")
parser.add_option("--sweep", dest="type", action="store_const",
const="sweep",
- help="generate a swept sine wave")
-
- (options, args) = parser.parse_args ()
- if len(args) != 0:
- parser.print_help()
- raise SystemExit, 1
-
- if options.tx_freq is None:
- parser.print_help()
- sys.stderr.write('You must specify the frequency with -f FREQ\n');
- raise SystemExit, 1
-
- return options
+ help="Generate a swept sine wave")
+ parser.add_option("-a", "--amplitude", type="eng_float", default=0.1,
+ help="Set output amplitude to AMPL (0.0-1.0)
[default=%default]", metavar="AMPL")
+ parser.add_option("-v", "--verbose", action="store_true", default=False,
+ help="Use verbose console output [default=%default]")
+ (options, args) = parser.parse_args()
-if __name__ == '__main__':
- options = get_options()
- tb = siggen_top_block(options)
+ return (options, args)
+
+# If this script is executed, the following runs. If it is imported, the below
does not run.
+if __name__ == "__main__":
+ if gr.enable_realtime_scheduling() != gr.RT_OK:
+ print "Note: failed to enable realtime scheduling, continuing"
- # Attempt to enable realtime scheduling
- r = gr.enable_realtime_scheduling()
- if r == gr.RT_OK:
- realtime = True
- else:
- realtime = False
- print "Note: failed to enable realtime scheduling"
+ # Grab command line options and create top block
+ try:
+ (options, args) = get_options()
+ tb = top_block(options, args)
+ except RuntimeError, e:
+ print e
+ sys.exit(1)
+
+ # Run it
try:
tb.run()
+
except KeyboardInterrupt:
pass
Added: gnuradio/trunk/gr-utils/src/python/usrp2_siggen_gui.py
===================================================================
--- gnuradio/trunk/gr-utils/src/python/usrp2_siggen_gui.py
(rev 0)
+++ gnuradio/trunk/gr-utils/src/python/usrp2_siggen_gui.py 2009-02-22
20:55:28 UTC (rev 10476)
@@ -0,0 +1,275 @@
+#!/usr/bin/env python
+#
+# Copyright 2009 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+import wx
+from gnuradio.wxgui import form, slider, gui
+import usrp2_siggen
+import math
+
+class app_gui(object):
+ def __init__(self, frame, panel, vbox, top_block, options, args):
+ self.frame = frame # Use for top-level application window frame
+ self.panel = panel # Use as parent class for created windows
+ self.vbox = vbox # Use as sizer for created windows
+ self.tb = top_block # GUI-unaware flowgraph class
+ self.options = options # Supplied command-line options
+ self.args = args # Supplied command-line arguments
+
+ freq_range = self.tb.freq_range()
+ self.min_freq = freq_range[0]
+ self.max_freq = freq_range[1]
+ self.freq_step = (self.max_freq-self.min_freq)/100.0
+ self._types = dict([v, k] for k, v in usrp2_siggen.waveforms.items())
+
+ self.build_gui()
+
+ # TODO: turn these into listeners
+ self.myform['ifc'].set_value(self.tb.ifc_name())
+ self.myform['mac'].set_value(self.tb.mac_addr())
+ dbid = self.tb.daughterboard_id()
+ self.myform['dbid'].set_value("%04x" % (dbid,))
+
+ w = usrp2_siggen.waveforms[self.tb.waveform_type()]
+ self.myform['type'].set_value(w)
+ self.myform['w1freq'].set_value(self.tb.waveform_freq())
+ self.myform['w2freq'].set_value(self.tb.waveform2_freq())
+
+ freq = self.tb.freq()
+ if freq is None:
+ self.evt_set_status_msg("Failed to set initial frequency")
+ else:
+ self.myform['freq'].set_value(freq)
+ self.myform['freq_slider'].set_value(self.tb.freq())
+
+ amp = self.tb.amplitude()
+ if (amp > 0.0):
+ db = 20*math.log10(amp)
+ else:
+ db = -100.0
+ self.myform['amp'].set_value(amp)
+ self.myform['amp_slider'].set_value(db)
+ self.myform['eth'].set_value(self.tb.eth_rate())
+ self.myform['gbe'].set_value(self.tb.eth_rate()*32)
+ self.myform['interp'].set_value(self.tb.interp_rate())
+ self.myform['DDC'].set_value(self.tb.ddc_freq())
+ self.myform['analog'].set_value(self.tb.baseband_freq())
+
+ # Event response handlers
+ def evt_set_status_msg(self, msg):
+ self.frame.SetStatusText(msg, 0)
+
+ def evt_set_freq1(self, kv):
+ return self.tb.set_waveform_freq(kv['w1freq'])
+
+ def evt_set_freq2(self, kv):
+ return self.tb.set_waveform2_freq(kv['w2freq'])
+
+ def evt_set_freq(self, kv):
+ if type(kv) == type(0.0): # Set from slider
+ tr = self.tb.set_freq(kv)
+ if tr is not None:
+ self.myform['freq'].set_value(kv)
+ else: # Set from edit box
+ f = kv['freq']
+ tr = self.tb.set_freq(f)
+ if tr is not None:
+ self.myform['freq_slider'].set_value(f)
+
+ if tr is not None:
+ self.myform['DDC'].set_value(tr.dxc_freq)
+ self.myform['analog'].set_value(tr.baseband_freq)
+
+ return (tr is not None)
+
+ def evt_set_amplitude(self, kv):
+ if type(kv) == type(0.0): # Set from slider
+ amp = math.pow(10, kv/20.0)
+ self.myform['amp'].set_value(amp)
+ return self.tb.set_amplitude(amp)
+ else: # Set from edit box
+ amp = kv['amp']
+ if amp < 0.0 or amp > 1.0:
+ return False
+ if amp == 0.0:
+ db = -100.0
+ else:
+ db = 20*math.log10(amp)
+ self.myform['amp_slider'].set_value(db)
+ return self.tb.set_amplitude(amp)
+
+ def evt_set_interp(self):
+ interp = self.myform['interp'].get_value()
+ if self.tb.set_interp(interp):
+ eth_rate = self.tb.eth_rate()
+ self.myform['eth'].set_value(eth_rate)
+ self.myform['gbe'].set_value(eth_rate*32)
+ return True
+ return False
+
+ def evt_set_waveform_type(self, type):
+ # TODO: update frequency labels
+ return self.tb.set_waveform(self._types[type])
+
+ # GUI construction
+ 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)
+
+if __name__ == "__main__":
+ try:
+ # Get command line parameters
+ (options, args) = usrp2_siggen.get_options()
+
+ # Create the top block using these
+ tb = usrp2_siggen.top_block(options, args)
+
+ # Create the GUI application
+ app = gui.app(top_block=tb, # Constructed top block
+ gui=app_gui, # User interface class
+ options=options, # Command line options
+ args=args, # Command line args
+ title="USRP2 Signal Generator", # Top window title
+ nstatus=1, # Number of status lines
+ start=True, # Whether to start
flowgraph
+ realtime=True) # Whether to set
realtime priority
+
+ # And run it
+ app.MainLoop()
+
+ except RuntimeError, e:
+ print e
+ sys.exit(1)
Property changes on: gnuradio/trunk/gr-utils/src/python/usrp2_siggen_gui.py
___________________________________________________________________
Name: svn:executable
+ *
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Commit-gnuradio] r10476 - gnuradio/trunk/gr-utils/src/python,
jcorgan <=