def __init__(self, fg, parent, unit='',base_value=0,minval=-100.0,maxval=100.0,factor=1.0,
decimal_places=10, ref_level=50, sample_rate=1, #number_size=512,
number_rate=default_number_rate, average=False, avg_alpha=None,
label='', size=default_numbersink_size, peak_hold=False):
number_sink_base.__init__(self, unit=unit, input_is_real=False, base_value=base_value,factor=factor,
minval=minval,maxval=maxval,decimal_places=decimal_places, ref_level=ref_level,
sample_rate=sample_rate, #number_size=number_size,
number_rate=number_rate,
average=average, avg_alpha=avg_alpha, label=label,
peak_hold=peak_hold)
number_size=1
one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex,
max(1, int(sample_rate/number_rate)))
#c2mag = gr.complex_to_mag(number_size)
self.avg = gr.single_pole_iir_filter_cc(1.0, number_size)
# FIXME We need to add 3dB to all bins but the DC bin
#log = gr.nlog10_ff(20, number_size,
# -20*math.log10(number_size)-10*math.log10(power/number_size))
sink = gr.message_sink(gr.sizeof_gr_complex , self.msgq, True)
#fg.connect (s2p, one_in_n, fft, c2mag, self.avg, log, sink)
fg.connect(self.avg,one_in_n,sink)
gr.hier_block.__init__(self, fg, self.avg, sink)
self.win = number_window(self, parent, size=size,label=label)
self.set_average(self.average)
def __init__(self,subdev_spec=None,gain=None,length=1,alpha=1.0,msgq=None,loopback=False,verbose=False,debug=False):
self._subdev_spec = subdev_spec
self._gain = gain
self._length = length
self._alpha = alpha
self._msgq = msgq
self._loopback = loopback
self._verbose = verbose
self._debug = debug
self._fg = gr.flow_graph()
self._u = usrp.source_c(fpga_filename='usrp_sounder.rbf')
if not self._loopback:
if self._subdev_spec == None:
self._subdev_spec = pick_subdevice(self._u)
self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
if self._verbose:
print "Using", self._subdev.name(), "for sounder receiver."
self.set_gain(self._gain)
self._vblen = gr.sizeof_gr_complex*self._length
if self._debug:
print "Generating impulse vectors of length", self._length, "byte length", self._vblen
self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
if self._verbose:
print "Using smoothing alpha of", self._alpha
self._lpf = gr.single_pole_iir_filter_cc(self._alpha, self._length)
self._sink = gr.message_sink(self._vblen, self._msgq, True)
self._fg.connect(self._u, self._s2v, self._lpf, self._sink)
def __init__(self,subdev_spec=None,gain=None,length=1,alpha=1.0,msgq=None,loopback=False,verbose=False,debug=False):
self._subdev_spec = subdev_spec
self._gain = gain
self._length = length
self._alpha = alpha
self._msgq = msgq
self._loopback = loopback
self._verbose = verbose
self._debug = debug
self._tb = gr.top_block()
self._u = usrp.source_c(fpga_filename='usrp_sounder.rbf')
if not self._loopback:
if self._subdev_spec == None:
self._subdev_spec = pick_subdevice(self._u)
self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
if self._verbose:
print "Using", self._subdev.name(), "for sounder receiver."
self.set_gain(self._gain)
self._vblen = gr.sizeof_gr_complex*self._length
if self._debug:
print "Generating impulse vectors of length", self._length, "byte length", self._vblen
self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
if self._verbose:
print "Using smoothing alpha of", self._alpha
self._lpf = gr.single_pole_iir_filter_cc(self._alpha, self._length)
self._sink = gr.message_sink(self._vblen, self._msgq, True)
self._tb.connect(self._u, self._s2v, self._lpf, self._sink)
def __init__(self, parent, unit='',base_value=0,minval=-100.0,maxval=100.0,factor=1.0,
decimal_places=10, ref_level=50, sample_rate=1,
number_rate=default_number_rate, average=False, avg_alpha=None,
label='', size=default_numbersink_size, peak_hold=False):
gr.hier_block2.__init__(self, "number_sink_c",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
number_sink_base.__init__(self, unit=unit, input_is_real=False, base_value=base_value,factor=factor,
minval=minval,maxval=maxval,decimal_places=decimal_places, ref_level=ref_level,
sample_rate=sample_rate, number_rate=number_rate,
average=average, avg_alpha=avg_alpha, label=label,
peak_hold=peak_hold)
number_size=1
one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex,
max(1, int(sample_rate/number_rate)))
self.avg = gr.single_pole_iir_filter_cc(1.0, number_size)
sink = gr.message_sink(gr.sizeof_gr_complex , self.msgq, True)
self.connect(self, self.avg, one_in_n, sink)
self.win = number_window(self, parent, size=size,label=label)
self.set_average(self.average)
self.set_peak_hold(self.peak_hold)
def test_002(self):
src_data = (complex(0,0), complex(1000,-1000), complex(2000,-2000), complex(3000,-3000), complex(4000,-4000), complex(5000,-5000))
expected_result = (complex(0,0), complex(125,-125), complex(359.375,-359.375), complex(689.453125,-689.453125), complex(1103.271484,-1103.271484), complex(1590.36255,-1590.36255))
src = gr.vector_source_c(src_data)
op = gr.single_pole_iir_filter_cc (0.125)
dst = gr.vector_sink_c()
self.fg.connect (src, op, dst)
self.fg.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual (expected_result, result_data, 3)
def test_001(self):
src_data = (0+0j, 1000+1000j, 2000+2000j, 3000+3000j, 4000+4000j, 5000+5000j)
expected_result = src_data
src = gr.vector_source_c(src_data)
op = gr.single_pole_iir_filter_cc (1.0)
dst = gr.vector_sink_c()
self.fg.connect (src, op, dst)
self.fg.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual (expected_result, result_data)
def test_001(self):
src_data = (0 + 0j, 1000 + 1000j, 2000 + 2000j, 3000 + 3000j,
4000 + 4000j, 5000 + 5000j)
expected_result = src_data
src = gr.vector_source_c(src_data)
op = gr.single_pole_iir_filter_cc(1.0)
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_result, result_data)
def test_003(self):
block_size = 2
src_data = (complex(0,0), complex(1000,-1000), complex(2000,-2000), complex(3000,-3000), complex(4000,-4000), complex(5000,-5000))
expected_result = (complex(0,0), complex(125,-125), complex(250,-250), complex(484.375,-484.375), complex(718.75,-718.75), complex(1048.828125,-1048.828125))
src = gr.vector_source_c(src_data)
s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, block_size)
op = gr.single_pole_iir_filter_cc (0.125, block_size)
p2s = gr.parallel_to_serial(gr.sizeof_gr_complex, block_size)
dst = gr.vector_sink_c()
self.fg.connect (src, s2p, op, p2s, dst)
self.fg.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual (expected_result, result_data, 3)
def test_002(self):
src_data = (complex(0, 0), complex(1000, -1000), complex(2000, -2000),
complex(3000, -3000), complex(4000,
-4000), complex(5000, -5000))
expected_result = (complex(0, 0), complex(125, -125),
complex(359.375,
-359.375), complex(689.453125, -689.453125),
complex(1103.271484, -1103.271484),
complex(1590.36255, -1590.36255))
src = gr.vector_source_c(src_data)
op = gr.single_pole_iir_filter_cc(0.125)
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_result, result_data, 3)
def test_003(self):
block_size = 2
src_data = (complex(0, 0), complex(1000, -1000), complex(2000, -2000),
complex(3000, -3000), complex(4000,
-4000), complex(5000, -5000))
expected_result = (complex(0, 0), complex(125,
-125), complex(250, -250),
complex(484.375,
-484.375), complex(718.75, -718.75),
complex(1048.828125, -1048.828125))
src = gr.vector_source_c(src_data)
s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, block_size)
op = gr.single_pole_iir_filter_cc(0.125, block_size)
p2s = gr.parallel_to_serial(gr.sizeof_gr_complex, block_size)
dst = gr.vector_sink_c()
self.tb.connect(src, s2p, op, p2s, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_result, result_data, 3)
def __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option)
parser.add_option("-e",
"--interface",
type="string",
default="eth0",
help="select Ethernet interface, default is eth0")
parser.add_option(
"-m",
"--mac-addr",
type="string",
default="",
help="select USRP by MAC address, default is auto-select")
parser.add_option("-W",
"--bw",
type="eng_float",
default=1e6,
help="set bandwidth of receiver [default=%default]")
parser.add_option("-f",
"--freq",
type="eng_float",
default=2412e6,
help="set frequency to FREQ",
metavar="FREQ")
parser.add_option("-g",
"--gain",
type="eng_float",
default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("--fft-size",
type="int",
default=2048,
help="Set number of FFT bins [default=%default]")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
self.options = options
self.show_debug_info = True
self.qapp = QtGui.QApplication(sys.argv)
self.u = usrp2.source_32fc(options.interface, options.mac_addr)
self._adc_rate = self.u.adc_rate()
self.set_bandwidth(options.bw)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.gain_range()
options.gain = float(g[0] + g[1]) / 2
self.set_gain(options.gain)
if options.freq is None:
# if no frequency was specified, use the mid-point of the subdev
f = self.u.freq_range()
options.freq = float(f[0] + f[1]) / 2
self.set_frequency(options.freq)
self._fftsize = options.fft_size
self.snk = qtgui.sink_c(options.fft_size,
gr.firdes.WIN_BLACKMAN_hARRIS, self._freq,
self._bandwidth, "USRP2 Display", True, True,
True, False)
# Set up internal amplifier
self.amp = gr.multiply_const_cc(0.0)
self.set_amplifier_gain(100)
# Create a single-pole IIR filter to remove DC
# but don't connect it yet
self.dc_gain = 0.001
self.dc = gr.single_pole_iir_filter_cc(self.dc_gain)
self.dc_sub = gr.sub_cc()
self.connect(self.u, self.amp, self.snk)
if self.show_debug_info:
print "Decimation rate: ", self._decim
print "Bandwidth: ", self._bandwidth
print "D'board: ", self.u.daughterboard_id()
# Get the reference pointer to the SpectrumDisplayForm QWidget
# Wrap the pointer as a PyQt SIP object
# This can now be manipulated as a PyQt4.QtGui.QWidget
self.pysink = sip.wrapinstance(self.snk.pyqwidget(), QtGui.QWidget)
self.main_win = main_window(self.pysink, self)
self.main_win.set_frequency(self._freq)
self.main_win.set_gain(self._gain)
self.main_win.set_bandwidth(self._bandwidth)
self.main_win.set_amplifier(self._amp_value)
self.main_win.show()
def __init__(self, options):
gr.top_block.__init__(self)
self.options = options
self.show_debug_info = True
self.qapp = QtGui.QApplication(sys.argv)
self.u = uhd.usrp_source(device_addr=options.address,
stream_args=uhd.stream_args('fc32'))
self.set_bandwidth(options.samp_rate)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start() + g.stop()) / 2
self.set_gain(options.gain)
if options.freq is None:
# if no freq was specified, use the mid-point
r = self.u.get_freq_range()
options.freq = float(r.start() + r.stop()) / 2
self.set_frequency(options.freq)
if (options.antenna):
self.u.set_antenna(options.antenna, 0)
self._fftsize = options.fft_size
self.snk = qtgui.sink_c(options.fft_size,
gr.firdes.WIN_BLACKMAN_hARRIS, self._freq,
self._bandwidth, "UHD Display", True, True,
True, False)
# Set up internal amplifier
self.amp = gr.multiply_const_cc(0.0)
self.set_amplifier_gain(100)
# Create a single-pole IIR filter to remove DC
# but don't connect it yet
self.dc_gain = 0.001
self.dc = gr.single_pole_iir_filter_cc(self.dc_gain)
self.dc_sub = gr.sub_cc()
self.connect(self.u, self.amp, self.snk)
if self.show_debug_info:
print "Bandwidth: ", self.u.get_samp_rate()
print "Center Freq: ", self.u.get_center_freq()
print "Freq Range: ", self.u.get_freq_range()
# Get the reference pointer to the SpectrumDisplayForm QWidget
# Wrap the pointer as a PyQt SIP object
# This can now be manipulated as a PyQt4.QtGui.QWidget
self.pysink = sip.wrapinstance(self.snk.pyqwidget(), QtGui.QWidget)
self.main_win = main_window(self.pysink, self)
self.main_win.set_frequency(self._freq)
self.main_win.set_gain(self._gain)
self.main_win.set_bandwidth(self._bandwidth)
self.main_win.set_amplifier(self._amp_value)
self.main_win.show()
def __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option)
parser.add_option("-e", "--interface", type="string", default="eth0",
help="select Ethernet interface, default is eth0")
parser.add_option("-m", "--mac-addr", type="string", default="",
help="select USRP by MAC address, default is auto-select")
parser.add_option("-W", "--bw", type="eng_float", default=1e6,
help="set bandwidth of receiver [default=%default]")
parser.add_option("-f", "--freq", type="eng_float", default=2412e6,
help="set frequency to FREQ", metavar="FREQ")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("--fft-size", type="int", default=2048,
help="Set number of FFT bins [default=%default]")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
self.options = options
self.show_debug_info = True
self.qapp = QtGui.QApplication(sys.argv)
self.u = usrp2.source_32fc(options.interface, options.mac_addr)
self._adc_rate = self.u.adc_rate()
self.set_bandwidth(options.bw)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.gain_range()
options.gain = float(g[0]+g[1])/2
self.set_gain(options.gain)
if options.freq is None:
# if no frequency was specified, use the mid-point of the subdev
f = self.u.freq_range()
options.freq = float(f[0]+f[1])/2
self.set_frequency(options.freq)
self._fftsize = options.fft_size
self.snk = qtgui.sink_c(options.fft_size, gr.firdes.WIN_BLACKMAN_hARRIS,
self._freq, self._bandwidth,
"USRP2 Display",
True, True, True, False)
# Set up internal amplifier
self.amp = gr.multiply_const_cc(0.0)
self.set_amplifier_gain(100)
# Create a single-pole IIR filter to remove DC
# but don't connect it yet
self.dc_gain = 0.001
self.dc = gr.single_pole_iir_filter_cc(self.dc_gain)
self.dc_sub = gr.sub_cc()
self.connect(self.u, self.amp, self.snk)
if self.show_debug_info:
print "Decimation rate: ", self._decim
print "Bandwidth: ", self._bandwidth
print "D'board: ", self.u.daughterboard_id()
# Get the reference pointer to the SpectrumDisplayForm QWidget
# Wrap the pointer as a PyQt SIP object
# This can now be manipulated as a PyQt4.QtGui.QWidget
self.pysink = sip.wrapinstance(self.snk.pyqwidget(), QtGui.QWidget)
self.main_win = main_window(self.pysink, self)
self.main_win.set_frequency(self._freq)
self.main_win.set_gain(self._gain)
self.main_win.set_bandwidth(self._bandwidth)
self.main_win.set_amplifier(self._amp_value)
self.main_win.show()
def __init__(
self,
parent,
unit="units",
minval=0,
maxval=1,
factor=1,
decimal_places=3,
ref_level=0,
sample_rate=1,
number_rate=number_window.DEFAULT_NUMBER_RATE,
average=False,
avg_alpha=None,
label="Number Plot",
size=number_window.DEFAULT_WIN_SIZE,
peak_hold=False,
show_gauge=True,
**kwargs # catchall for backwards compatibility
):
# ensure avg alpha
if avg_alpha is None:
avg_alpha = 2.0 / number_rate
# init
gr.hier_block2.__init__(self, "number_sink", gr.io_signature(1, 1, self._item_size), gr.io_signature(0, 0, 0))
# blocks
sd = blks2.stream_to_vector_decimator(
item_size=self._item_size, sample_rate=sample_rate, vec_rate=number_rate, vec_len=1
)
if self._real:
mult = gr.multiply_const_ff(factor)
add = gr.add_const_ff(ref_level)
avg = gr.single_pole_iir_filter_ff(1.0)
else:
mult = gr.multiply_const_cc(factor)
add = gr.add_const_cc(ref_level)
avg = gr.single_pole_iir_filter_cc(1.0)
msgq = gr.msg_queue(2)
sink = gr.message_sink(self._item_size, msgq, True)
# controller
self.controller = pubsub()
self.controller.subscribe(SAMPLE_RATE_KEY, sd.set_sample_rate)
self.controller.publish(SAMPLE_RATE_KEY, sd.sample_rate)
self.controller[AVERAGE_KEY] = average
self.controller[AVG_ALPHA_KEY] = avg_alpha
def update_avg(*args):
if self.controller[AVERAGE_KEY]:
avg.set_taps(self.controller[AVG_ALPHA_KEY])
else:
avg.set_taps(1.0)
update_avg()
self.controller.subscribe(AVERAGE_KEY, update_avg)
self.controller.subscribe(AVG_ALPHA_KEY, update_avg)
# start input watcher
common.input_watcher(msgq, self.controller, MSG_KEY)
# create window
self.win = number_window.number_window(
parent=parent,
controller=self.controller,
size=size,
title=label,
units=unit,
real=self._real,
minval=minval,
maxval=maxval,
decimal_places=decimal_places,
show_gauge=show_gauge,
average_key=AVERAGE_KEY,
avg_alpha_key=AVG_ALPHA_KEY,
peak_hold=peak_hold,
msg_key=MSG_KEY,
sample_rate_key=SAMPLE_RATE_KEY,
)
common.register_access_methods(self, self.controller)
# backwards compadibility
self.set_show_gauge = self.win.show_gauges
# connect
self.wxgui_connect(self, sd, mult, add, avg, sink)
def __init__(self, options):
gr.top_block.__init__(self)
self.options = options
self.show_debug_info = True
self.qapp = QtGui.QApplication(sys.argv)
self.u = uhd.usrp_source(device_addr=options.address,
io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1)
self.set_bandwidth(options.samp_rate)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2
self.set_gain(options.gain)
if options.freq is None:
# if no freq was specified, use the mid-point
r = self.u.get_freq_range()
options.freq = float(r.start()+r.stop())/2
self.set_frequency(options.freq)
if(options.antenna):
self.u.set_antenna(options.antenna, 0)
self._fftsize = options.fft_size
self.snk = qtgui.sink_c(options.fft_size,
gr.firdes.WIN_BLACKMAN_hARRIS,
self._freq, self._bandwidth,
"UHD Display",
True, True, True, False)
# Set up internal amplifier
self.amp = gr.multiply_const_cc(0.0)
self.set_amplifier_gain(100)
# Create a single-pole IIR filter to remove DC
# but don't connect it yet
self.dc_gain = 0.001
self.dc = gr.single_pole_iir_filter_cc(self.dc_gain)
self.dc_sub = gr.sub_cc()
self.connect(self.u, self.amp, self.snk)
if self.show_debug_info:
print "Bandwidth: ", self.u.get_samp_rate()
print "Center Freq: ", self.u.get_center_freq()
print "Freq Range: ", self.u.get_freq_range()
# Get the reference pointer to the SpectrumDisplayForm QWidget
# Wrap the pointer as a PyQt SIP object
# This can now be manipulated as a PyQt4.QtGui.QWidget
self.pysink = sip.wrapinstance(self.snk.pyqwidget(), QtGui.QWidget)
self.main_win = main_window(self.pysink, self)
self.main_win.set_frequency(self._freq)
self.main_win.set_gain(self._gain)
self.main_win.set_bandwidth(self._bandwidth)
self.main_win.set_amplifier(self._amp_value)
self.main_win.show()
def __init__(
self,
parent,
unit='units',
minval=0,
maxval=1,
factor=1,
decimal_places=3,
ref_level=0,
sample_rate=1,
number_rate=number_window.DEFAULT_NUMBER_RATE,
average=False,
avg_alpha=None,
label='Number Plot',
size=number_window.DEFAULT_WIN_SIZE,
peak_hold=False,
show_gauge=True,
**kwargs #catchall for backwards compatibility
):
#ensure avg alpha
if avg_alpha is None: avg_alpha = 2.0 / number_rate
#init
gr.hier_block2.__init__(
self,
"number_sink",
gr.io_signature(1, 1, self._item_size),
gr.io_signature(0, 0, 0),
)
#blocks
sd = blks2.stream_to_vector_decimator(
item_size=self._item_size,
sample_rate=sample_rate,
vec_rate=number_rate,
vec_len=1,
)
if self._real:
mult = gr.multiply_const_ff(factor)
add = gr.add_const_ff(ref_level)
avg = gr.single_pole_iir_filter_ff(1.0)
else:
mult = gr.multiply_const_cc(factor)
add = gr.add_const_cc(ref_level)
avg = gr.single_pole_iir_filter_cc(1.0)
msgq = gr.msg_queue(2)
sink = gr.message_sink(self._item_size, msgq, True)
#controller
self.controller = pubsub()
self.controller.subscribe(SAMPLE_RATE_KEY, sd.set_sample_rate)
self.controller.publish(SAMPLE_RATE_KEY, sd.sample_rate)
self.controller[AVERAGE_KEY] = average
self.controller[AVG_ALPHA_KEY] = avg_alpha
def update_avg(*args):
if self.controller[AVERAGE_KEY]:
avg.set_taps(self.controller[AVG_ALPHA_KEY])
else:
avg.set_taps(1.0)
update_avg()
self.controller.subscribe(AVERAGE_KEY, update_avg)
self.controller.subscribe(AVG_ALPHA_KEY, update_avg)
#start input watcher
common.input_watcher(msgq, self.controller, MSG_KEY)
#create window
self.win = number_window.number_window(
parent=parent,
controller=self.controller,
size=size,
title=label,
units=unit,
real=self._real,
minval=minval,
maxval=maxval,
decimal_places=decimal_places,
show_gauge=show_gauge,
average_key=AVERAGE_KEY,
avg_alpha_key=AVG_ALPHA_KEY,
peak_hold=peak_hold,
msg_key=MSG_KEY,
sample_rate_key=SAMPLE_RATE_KEY,
)
common.register_access_methods(self, self.controller)
#backwards compadibility
self.set_show_gauge = self.win.show_gauges
#connect
self.wxgui_connect(self, sd, mult, add, avg, sink)
