def main ():
try:
app = stdgui2.stdapp(app_top_block, "UHD FFT", nstatus=1)
app.MainLoop()
except RuntimeError, e:
print e
sys.exit(1)
def main():
app = stdgui2.stdapp(demo_graph, "Slider Demo")
app.MainLoop()
def main():
app = stdgui2.stdapp(ptt_block, "NBFM Push to Talk")
app.MainLoop()
def threshold(self):
t = self.squelch.threshold()
#print "t =", t
return t
def set_freq(self, target_freq):
"""
Set the center frequency we're interested in.
@param target_freq: frequency in Hz
@rypte: bool
"""
r = self.u.set_center_freq(target_freq)
if r:
return True
return False
def set_gain(self, gain):
self.gain = gain
self.u.set_gain(gain)
# ////////////////////////////////////////////////////////////////////////
# Main
# ////////////////////////////////////////////////////////////////////////
if __name__ == '__main__':
app = stdgui2.stdapp (my_top_block, "USRP NBFM RX")
app.MainLoop ()
def main():
app = stdgui2.stdapp(test_top_block, "O'Scope Test App")
app.MainLoop()
if not (self.u is None):
r = self.u.set_center_freq(target_freq)
if r:
self.freq = target_freq
self.myform['freq'].set_value(target_freq) # update displayed value
self.myform['freq_slider'].set_value(target_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_gain(self, gain):
if not (self.u is None):
self.gain=gain
self.myform['gain'].set_value(gain) # update displayed value
self.u.set_gain(gain)
self.update_status_bar()
def update_status_bar (self):
msg = "Setting:%s Contrast:%r Brightness:%r Gain: %r" % \
(self.state, self.contrast,self.brightness,self.gain)
self._set_status_msg(msg, 1)
#self.src_fft.set_baseband_freq(self.freq)
if __name__ == '__main__':
app = stdgui2.stdapp (tv_rx_block, "USRP TV RX black-and-white")
app.MainLoop ()
def main():
app = stdgui2.stdapp(test_top_block, "Waterfall Sink Test App")
app.MainLoop()
def main ():
app = stdgui2.stdapp(app_flow_graph, "USRP FastAutoCorrelation", nstatus=1)
app.MainLoop()
def main():
app = stdgui2.stdapp(my_top_block, "Multi Scope", nstatus=1)
app.MainLoop()
def _build_gui(self, vbox, usrp_rate, audio_rate): # Waterfall before channel filter self.waterfall = waterfallsink2.waterfall_sink_c(self.panel, title="USRP", fft_size=512, sample_rate=usrp_rate, baseband_freq=self.freq) self.connect(self.usrp, self.waterfall) vbox.Add(self.waterfall.win, 4, wx.EXPAND) # FFT after channel filter self.post_filt_fft = fftsink2.fft_sink_c(self.panel, title="Post Channel filter", fft_size=512, sample_rate=usrp_rate, baseband_freq=self.freq, peak_hold=True) self.connect(self.chan_filt, self.post_filt_fft) vbox.Add(self.post_filt_fft.win, 4, wx.EXPAND) self.post_filt_fft.win.autoscale() if __name__ == '__main__': app = stdgui2.stdapp(acars_rx, "USRP ACARS RX") app.MainLoop()
if r:
self.freq = target_freq
self.myform['freq'].set_value(
target_freq) # update displayed value
self.myform['freq_slider'].set_value(
target_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_gain(self, gain):
self.myform['gain'].set_value(gain) # update displayed value
self.u.set_pga(0, gain)
def update_status_bar(self):
msg = "Volume:%r Setting:%s" % (self.vol, self.state)
self._set_status_msg(msg, 1)
#self.src_fft.set_baseband_freq(self.freq)
#
# def volume_range(self):
# return (-20.0, 0.0, 0.5)
if __name__ == '__main__':
app = stdgui2.stdapp(wfm_rx_block, "MSDD FFT RX")
app.MainLoop()
sample_rate = 2e6
center_freq = 300e6
filename = '/home/sdr/Desktop/Lab/Labs/Multicode/multi_code_300MHz_2Mss.raw'
fsrc = blocks.file_source(gr.sizeof_gr_complex, filename, True)
throt = blocks.throttle(gr.sizeof_gr_complex, sample_rate)
c_to_m = blocks.complex_to_mag()
#scope = scopesink2.scope_sink_f(panel, sample_rate=sample_rate, size=(1200,800))
rat = filter.fir_filter_ccc(100, filter.firdes.low_pass_2(1, sample_rate, 1000000, 500000, 100))
detector = detect_opener_bits()
squelch = analog.pwr_squelch_cc(-60,1,0,False)
slicer = digital.binary_slicer_fb()
add = blocks.add_const_vff((-.003, ))
self.connect(fsrc, throt)
self.connect(throt, rat)
self.connect(rat, c_to_m)
self.connect(c_to_m, add)
self.connect(add, slicer)
#self.connect(c_to_m, scope)
self.connect(slicer, detector)
#vbox.Add(scope.win, 1, wx.EXPAND)
if __name__ == '__main__':
try:
app = stdgui2.stdapp(my_gui_flow_graph, "garage")
app.MainLoop()
except [[KeyboardInterrupt]]:
pass
1,
taps=lpf_tx_coeffs)
usrp_tx = usrp.sink_c(0, usrp_interpolation)
self.usrp_tx = usrp_tx
speaker = audio.sink(audio_rate, "plughw:0,0")
self.connect(callgever, lpf, fsk_f)
self.connect(fsk_f, fsk_c, fsk_resample, usrp_tx)
#self.connect(fsk_f, speaker)
# Set Multiplexer
mux = usrp.determine_tx_mux_value(usrp_tx, tx_subdev)
usrp_tx.set_mux(mux)
# Select subdevice
usrp_tx_subdev = usrp.selected_subdev(usrp_tx, tx_subdev)
# Tune subdevice
usrp_tx.tune(usrp_tx_subdev._which, usrp_tx_subdev, tx_frequency)
# Enable Transmitter (Required if using one of the Flex boards)
usrp_tx_subdev.set_enable(True)
# Main caller program
if __name__ == '__main__':
aplication = stdgui2.stdapp(rtty_graph, "RTTY generator")
aplication.MainLoop()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_sca_freq(self, target_sca_freq):
self.ddc.set_center_freq(-target_sca_freq)
self.myform['sca_freq'].set_value(target_sca_freq) # update displayed value
self.myform['sca_freq_slider'].set_value(target_sca_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
def set_gain(self, gain):
self.myform['gain'].set_value(gain) # update displayed value
self.u.set_gain(gain)
def update_status_bar (self):
msg = "Volume:%r Setting:%s" % (self.vol, self.state)
self._set_status_msg(msg, 1)
self.src_fft.set_baseband_freq(self.freq)
def volume_range(self):
return (-20.0, 0.0, 0.5)
if __name__ == '__main__':
app = stdgui2.stdapp (wfm_rx_sca_block, "USRP WFM SCA RX")
app.MainLoop ()
self._set_status_msg("Failed", 0)
return False
def set_sca_freq(self, target_sca_freq):
self.ddc.set_center_freq(-target_sca_freq)
self.myform['sca_freq'].set_value(
target_sca_freq) # update displayed value
self.myform['sca_freq_slider'].set_value(
target_sca_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
def set_gain(self, gain):
self.myform['gain'].set_value(gain) # update displayed value
self.u.set_gain(gain)
def update_status_bar(self):
msg = "Volume:%r Setting:%s" % (self.vol, self.state)
self._set_status_msg(msg, 1)
self.src_fft.set_baseband_freq(self.freq)
def volume_range(self):
return (-20.0, 0.0, 0.5)
if __name__ == '__main__':
app = stdgui2.stdapp(wfm_rx_sca_block, "USRP WFM SCA RX")
app.MainLoop()
def main ():
app = stdgui2.stdapp (test_top_block, "Waterfall Sink Test App")
app.MainLoop ()
def main(): app = stdgui2.stdapp(app_flow_graph, "GSM Scanner", nstatus=1) app.MainLoop()
def main ():
sys.stderr.write("GNU Radio Multichannel APCO P25 Tx (c) Copyright 2009,2010 KA1RBI\n")
app = stdgui2.stdapp(fm_tx_block, "Multichannel APCO P25 Tx", nstatus=1)
app.MainLoop ()
def main ():
app = stdgui2.stdapp (demo_graph, "Slider Demo")
app.MainLoop ()
myform['decim'] = form.int_field(
parent=panel, sizer=hbox, label="Decim",
callback=myform.check_input_and_call(_form_set_decim, self._set_status_msg))
hbox.Add((5,0), 1)
myform['fs@usb'] = form.static_float_field(
parent=panel, sizer=hbox, label="Fs@USB")
hbox.Add((5,0), 1)
myform['dbname'] = form.static_text_field(
parent=panel, sizer=hbox)
hbox.Add((5,0), 1)
myform['baseband'] = form.static_float_field(
parent=panel, sizer=hbox, label="Analog BB")
hbox.Add((5,0), 1)
myform['ddc'] = form.static_float_field(
parent=panel, sizer=hbox, label="DDC")
hbox.Add((5,0), 0)
vbox.Add(hbox, 0, wx.EXPAND)
if __name__ == '__main__':
app = stdgui2.stdapp(app_top_block, "GUI GNU Radio Application", nstatus=1)
app.MainLoop()
fft_size=256,
sample_rate=lpf_rate)
self.connect(chan_filter, post_demod)
vbox.Add(post_demod.win, 1, wx.EXPAND)
if False:
post_filt = fftsink2.fft_sink_f(panel,
title="Post Envelope Detector",
fft_size=512,
sample_rate=lpf_rate)
self.connect(magblock, post_filt)
vbox.Add(post_filt.win, 1, wx.EXPAND)
def parseargs(args):
nargs = len(args)
# multiplies the input frequency by 1000 to put in Hz
if nargs == 1:
freq1 = float(args[0]) * 1e3
else:
sys.stderr.write('usage: am_rcv freq1\n')
sys.exit(1)
return freq1
if __name__ == '__main__':
app = stdgui2.stdapp(am_rx_graph, "AM RX")
app.MainLoop()
def main ():
app = stdgui2.stdapp(test_app_flow_graph, "antenna_diagram Test App")
app.MainLoop()
def main ():
app = stdgui2.stdapp(app_flow_graph, "3d")
app.MainLoop ()
def main ():
app = stdgui2.stdapp (test_app_flow_graph, "fac Sink Test App")
app.MainLoop ()
def main ():
app = stdgui2.stdapp (test_top_block, "O'Scope Test App")
app.MainLoop ()
def main():
app = stdgui2.stdapp(ptt_block, "NBFM Push to Talk")
app.MainLoop()
def main ():
app = stdgui2.stdapp(app_flow_graph, "USRP Mode S O'scope", nstatus=1)
app.MainLoop()
def main ():
app = stdgui2.stdapp (test_app_block, "ESPRIT Sink Test App")
app.MainLoop ()
def main():
app = stdgui2.stdapp(app_top_block, "FFT Wav Player", nstatus=1)
app.MainLoop()
def main ():
app = stdgui2.stdapp(demo_app_flow_graph, "UmTRX control GUI", nstatus=1)
app.MainLoop ()
return False def set_gain(self, gain): self.myform['gain'].set_value(gain) self.subdev.set_gain(gain) def update_status_bar (self): msg = "Volume:%r, Gain:%r, Freq:%3.1f MHz" % (self.vol, self.gain, self.freq/1e6) self._set_status_msg(msg, 1) def volume_range(self): return (-20.0, 0.0, 0.5) # hardcoded values def Seek_Up(self, event): new_freq = self.freq + 1e5 if new_freq > 108e6: new_freq=88e6 self.set_freq(new_freq) def Seek_Down(self, event): new_freq = self.freq - 1e5 if new_freq < 88e6: new_freq=108e6 self.set_freq(new_freq) if __name__ == '__main__': app = stdgui2.stdapp (rds_rx_graph, "USRP RDS RX") app.MainLoop ()
def main ():
app = stdgui2.stdapp(fm_tx_block, "Multichannel FM Tx", nstatus=1)
app.MainLoop ()
def main ():
" Go, go, go! "
app = stdgui2.stdapp (test_app_block, "ESPRIT Sink Test App")
app.MainLoop ()
def main():
app = stdgui2.stdapp(demo_app_flow_graph, "wxgui form demo", nstatus=1)
app.MainLoop()
def main ():
app = stdgui2.stdapp(app_flow_graph, "RADIO ASTRONOMY PULSAR RECEIVER: $Revision: 7241 $", nstatus=1)
app.MainLoop()
"""
r = usrp.tune(self.u, 0, self.subdev, target_freq)
if r:
self.freq = target_freq
self.myform['freq'].set_value(target_freq) # update displayed value
self.myform['freq_slider'].set_value(target_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_gain(self, gain):
self.myform['gain'].set_value(gain) # update displayed value
self.subdev.set_gain(gain)
def update_status_bar (self):
msg = "Volume:%r Setting:%s" % (self.vol, self.state)
self._set_status_msg(msg, 1)
self.src_fft.set_baseband_freq(self.freq)
def volume_range(self):
return (-20.0, 0.0, 0.5)
if __name__ == '__main__':
app = stdgui2.stdapp (wxapt_rx_block, "USRP WXAPT RX")
app.MainLoop ()
def main ():
app = stdgui2.stdapp (test_app_flow_graph,
"FFT Sink Test App")
app.MainLoop ()
r = self.u.set_center_freq(target_freq)
if r:
self.freq = target_freq
self.myform['freq'].set_value(
target_freq) # update displayed value
self.myform['freq_slider'].set_value(
target_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_gain(self, gain):
self.myform['gain'].set_value(gain) # update displayed value
self.u.set_gain(gain)
def update_status_bar(self):
msg = "Volume:%r Setting:%s" % (self.vol, self.state)
self._set_status_msg(msg, 1)
self.src_fft.set_baseband_freq(self.freq)
def volume_range(self):
return (-20.0, 0.0, 0.5)
if __name__ == '__main__':
app = stdgui2.stdapp(wfm_rx_block, "USRP2 WFM RX")
app.MainLoop()
r = self.u.set_center_freq(target_freq)
if r:
self.freq = target_freq
self.myform['freq'].set_value(target_freq) # update displayed value
self.myform['freq_slider'].set_value(target_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_gain(self, gain):
self.myform['gain'].set_value(gain) # update displayed value
self.u.set_gain(gain)
def update_status_bar (self):
msg = "Volume:%r Setting:%s" % (self.vol, self.state)
self._set_status_msg(msg, 1)
self.src_fft.set_baseband_freq(self.freq)
def volume_range(self):
return (-20.0, 0.0, 0.5)
if __name__ == '__main__':
app = stdgui2.stdapp (wxapt_rx_block, "USRP WXAPT RX")
app.MainLoop ()
if not (self.u is None):
r = self.u.set_center_freq(target_freq)
if r:
self.freq = target_freq
self.myform['freq'].set_value(target_freq) # update displayed value
self.myform['freq_slider'].set_value(target_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_gain(self, gain):
if not (self.u is None):
self.gain=gain
self.myform['gain'].set_value(gain) # update displayed value
self.u.set_gain(gain)
self.update_status_bar()
def update_status_bar (self):
msg = "Setting:%s Contrast:%r Brightness:%r Gain: %r" % \
(self.state, self.contrast,self.brightness,self.gain)
self._set_status_msg(msg, 1)
#self.src_fft.set_baseband_freq(self.freq)
if __name__ == '__main__':
app = stdgui2.stdapp (tv_rx_block, "USRP TV RX black-and-white")
app.MainLoop ()
'magenta', 'brown', 'black'
]
r = records[0] # input data
for i in range(self.num_plots):
points = []
for j in range(self.samples_per_symbol):
p = [j, r[i * self.samples_per_symbol + j]]
points.append(p)
objects.append(
plot.PolyLine(points,
colour=colors[i % len(colors)],
legend=('')))
graphics = plot.PlotGraphics(objects,
title='Data Scope',
xLabel='Time',
yLabel='Amplitude')
x_range = (0., 0. + (self.samples_per_symbol - 1)
) # ranges are tuples!
self.y_range = (-4., 4.) # for standard -3/-1/+1/+3
self.Draw(graphics, xAxis=x_range, yAxis=self.y_range)
# Start the receiver
#
if '__main__' == __name__:
app = stdgui2.stdapp(p25_rx_block, "APCO P25 Receiver", 3)
app.MainLoop()
if self.correct_ffe_usrp:
print "--> correcting FFE on USRP"
self.run_correct_ffe_thread = True
self.ffe_updater = threading.Timer(0.1, self.correct_ffe)
self.ffe_updater.setDaemon(True)
self.ffe_updater.start()
def correct_ffe(self):
while self.run_correct_ffe_thread:
diff = self.demod.sync.ffs_sample_and_average_arg.ffe_estimate()
if abs(diff) > self.rx_params.usrp_ffc_min_deviation:
self.frequency -= diff * self.rx_params.usrp_ffc_adapt_factor
print "--> updating fine frequency correction: " + str(
self.frequency)
self.set_freq(self.frequency)
time.sleep(1. / self.rx_params.usrp_ffc_retune_frequency)
def set_freq(self, freq):
if self.src.set_center_freq(freq):
if self.verbose:
print "--> retuned to " + str(freq) + " Hz"
return True
else:
print "-> error - cannot tune to " + str(freq) + " Hz"
return False
if __name__ == '__main__':
app = stdgui2.stdapp(usrp_dab_gui_rx, "usrp_dab_gui_rx", nstatus=1)
app.MainLoop()
def main():
app = stdgui2.stdapp(fm_tx_block, "Multichannel FM Tx", nstatus=1)
app.MainLoop()
label="Decim",
callback=myform.check_input_and_call(
_form_set_decim,
self._set_status_msg))
hbox.Add((5, 0), 1)
myform['fs@usb'] = form.static_float_field(parent=panel,
sizer=hbox,
label="Fs@USB")
hbox.Add((5, 0), 1)
myform['dbname'] = form.static_text_field(parent=panel, sizer=hbox)
hbox.Add((5, 0), 1)
myform['baseband'] = form.static_float_field(parent=panel,
sizer=hbox,
label="Analog BB")
hbox.Add((5, 0), 1)
myform['ddc'] = form.static_float_field(parent=panel,
sizer=hbox,
label="DDC")
hbox.Add((5, 0), 0)
vbox.Add(hbox, 0, wx.EXPAND)
if __name__ == '__main__':
app = stdgui2.stdapp(app_top_block, "GUI GNU Radio Application", nstatus=1)
app.MainLoop()
from gnuradio import gr, blocks
import iio_swig as iio
from gnuradio.wxgui import stdgui2, fftsink2, slider, form, scopesink2
import wx
import iio_swig as iio
try:
from gnuradio import analog
except ImportError:
sys.stderr.write("Error: Program requires gr-analog.\n")
sys.exit(1)
class my_gui_flow_graph(stdgui2.std_top_block):
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv)
sample_rate = 122880000
ampl = 1
#src = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 2000000, ampl)
src = iio.fmcomms_source()
my_fft = scopesink2.scope_sink_f(panel, title="Osciloscope", sample_rate=sample_rate)
self.connect(src, my_fft)
vbox.Add(my_fft.win, 1, wx.EXPAND)
if __name__ == '__main__':
app = stdgui2.stdapp(my_gui_flow_graph, "GUI GNU Radio Application")
app.MainLoop()
self.myform['freq'].set_value(
target_freq) # update displayed value
self.myform['freq_slider'].set_value(
target_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_gain(self, gain):
self.myform['gain'].set_value(gain) # update displayed value
self.u.set_gain(gain)
def update_status_bar(self):
msg = "Volume:%r Setting:%s" % (self.vol, self.state)
self._set_status_msg(msg, 1)
try:
self.src_fft.set_baseband_freq(self.freq)
except:
None
def volume_range(self):
return (-40.0, 0.0, 0.5)
if __name__ == '__main__':
app = stdgui2.stdapp(wfm_rx_block, "USRP Broadcast AM MW RX")
app.MainLoop()
Tuning is a two step process. First we ask the front-end to
tune as close to the desired frequency as it can. Then we use
the result of that operation and our target_frequency to
determine the value for the digital down converter in the
FPGA. Finally, we feed any residual_freq to the s/w freq
translator.
"""
r = usrp.tune(self.u, 0, self.subdev, target_freq)
if r:
# Use residual_freq in s/w freq translater
# print "residual_freq =", r.residual_freq
self.ddc.set_center_freq(-r.residual_freq)
return True
return False
def set_gain(self, gain):
self.gain = gain
self.subdev.set_gain(gain)
# ////////////////////////////////////////////////////////////////////////
# Main
# ////////////////////////////////////////////////////////////////////////
if __name__ == '__main__':
app = stdgui2.stdapp(my_top_block, "USRP NBFM RX")
app.MainLoop()
def main ():
sys.stderr.write("GNU Radio Multichannel APCO P25 Tx (c) Copyright 2009, KA1RBI\n")
app = stdgui2.stdapp(fm_tx_block, "Multichannel APCO P25 Tx", nstatus=1)
app.MainLoop ()
self.ffe_updater = threading.Timer(0.1, self.correct_ffe) self.ffe_updater.setDaemon(True) self.ffe_updater.start() def correct_ffe(self): while self.run_correct_ffe_thread: diff = self.demod.sync.ffs_sample_and_average_arg.ffe_estimate() if abs(diff) > self.rx_params.usrp_ffc_min_deviation: self.frequency -= diff*self.rx_params.usrp_ffc_adapt_factor print "--> updating fine frequency correction: " + str(self.frequency) self.set_freq(self.frequency) time.sleep(1./self.rx_params.usrp_ffc_retune_frequency) def set_freq(self, freq): if self.src.set_center_freq(freq, 0): if self.verbose: print "--> retuned to " + str(freq) + " Hz" return True else: print "-> error - cannot tune to " + str(freq) + " Hz" return False if __name__ == '__main__': app = stdgui2.stdapp(usrp_dab_gui_rx, "usrp_dab_gui_rx", nstatus=1) app.MainLoop()
def main ():
app = stdgui2.stdapp(app_top_block, "UHD FFT", nstatus=1)
app.MainLoop()
def main():
app = stdgui2.stdapp(app_flow_graph,
"RADIO ASTRONOMY PULSAR RECEIVER: $Revision$",
nstatus=1)
app.MainLoop()
def main():
app = stdgui2.stdapp(app_top_block, "USRP FFT", nstatus=1)
app.MainLoop()
if r:
self.freq = target_freq
self.myform['freq'].set_value(target_freq) # update displayed value
self.myform['freq_slider'].set_value(target_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_gain(self, gain):
self.myform['gain'].set_value(gain) # update displayed value
self.u.set_gain(gain)
def update_status_bar (self):
msg = "Volume:%r Setting:%s" % (self.vol, self.state)
self._set_status_msg(msg, 1)
try:
self.src_fft.set_baseband_freq(self.freq)
except:
None
def volume_range(self):
return (-40.0, 0.0, 0.5)
if __name__ == '__main__':
app = stdgui2.stdapp (wfm_rx_block, "USRP Broadcast AM MW RX")
app.MainLoop ()
determine the value for the digital down converter.
"""
r = self.u.set_center_freq(target_freq)
if r:
self.freq = target_freq
self.myform['freq'].set_value(target_freq) # update displayed value
self.myform['freq_slider'].set_value(target_freq) # update displayed value
self.update_status_bar()
self._set_status_msg("OK", 0)
return True
self._set_status_msg("Failed", 0)
return False
def set_gain(self, gain):
self.myform['gain'].set_value(gain) # update displayed value
self.u.set_gain(gain)
def update_status_bar (self):
msg = "Volume:%r Setting:%s" % (self.vol, self.state)
self._set_status_msg(msg, 1)
self.src_fft.set_baseband_freq(self.freq)
def volume_range(self):
return (-20.0, 0.0, 0.5)
if __name__ == '__main__':
app = stdgui2.stdapp (wfm_rx_block, "USRP2 WFM RX")
app.MainLoop ()
#!/usr/bin/env python
from gnuradio import gr
from gnuradio.wxgui import stdgui2,fftsink2,scopesink2
import wx
class gnuradioGUI(stdgui2.std_top_block):
def __init__(self,frame,panel,vbox,argv):
stdgui2.std_top_block.__init__(self,frame,panel,vbox,argv)
fft = fftsink2.fft_sink_f(panel, title="FFT display", fft_size=512, sample_rate=100000)
vbox.Add(fft.win,4,wx.EXPAND)
scope = scopesink2.scope_sink_f(panel, title="Oscilloscope", sample_rate=100000)
vbox.Add(scope.win,4,wx.EXPAND)
signal = gr.sig_source_f(100000,gr.GR_SIN_WAVE,20000,1000,0)
throttle = gr.throttle(gr.sizeof_float,100000)
self.connect(signal,throttle)
self.connect(throttle,fft)
self.connect(throttle,scope)
if __name__ == '__main__':
app = stdgui2.stdapp(gnuradioGUI,"A simple GNU Radio GUI")
app.MainLoop()
action="store_true",
default=False,
help="dump debug .dat files")
parser.add_option("-L",
"--low-pass",
type="eng_float",
default=25e3,
help="low pass cut-off",
metavar="Hz")
parser.add_option("-o",
"--output-file",
type="string",
default="out.float",
help="specify the bit output file")
parser.add_option("-v",
"--verbose",
action="store_true",
default=False,
help="dump demodulation data")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
raise SystemExit, 1
return (options)
if __name__ == "__main__":
app = stdgui2.stdapp(my_top_block, "OsmoTETRA FCDP", nstatus=1)
app.MainLoop()
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=32000,
fft_size=1024,
fft_rate=30,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
vbox.Add(my_fft.win, 1, wx.EXPAND)
dqpsk_mod = blks2.dqpsk_mod(
samples_per_symbol=2,
excess_bw=0.35,
gray_code=True,
)
self.connect(random_source_x_0, dqpsk_mod)
self.connect(dqpsk_mod, my_fft)
if __name__ == '__main__':
app = stdgui2.stdapp(my_qpsk, "QPSK high rate")
app.MainLoop()
def main ():
app = stdgui2.stdapp(test_app_block, "FFT Sink Test App")
app.MainLoop()
def main():
app = stdgui2.stdapp(test_app_flow_graph, "wx_radar_py_f Test App")
app.MainLoop()