def setup_flowgraph(self, mode, ber_skipbytes=0): # parameters self.dp.set_mode(mode) self.rp.set_mode(mode) self.vlen = self.dp.num_carriers/4 self.ber_skipbytes = ber_skipbytes # trigger signals frame_trigger = [1]+[0]*(self.dp.symbols_per_frame-2) self.frame_start = frame_trigger*(len(self.random_bytes)/(self.vlen*(self.dp.symbols_per_frame-1)))+frame_trigger[0:(len(self.random_bytes)/self.vlen)%(self.dp.symbols_per_frame-1)] # sources/sinks self.source = gr.vector_source_b(self.random_bytes, False) self.trig = gr.vector_source_b(self.frame_start, False) if self.ber_sink: self.sink = dab.blocks.measure_ber_b() else: self.sink = gr.vector_sink_b() self.trig_sink = gr.null_sink(gr.sizeof_char) # self.noise_start = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(2), random.randint(0,10000)) # self.noise_start_head = gr.head(gr.sizeof_gr_complex, NOISE_SAMPLES_AT_START) # self.noise_end = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(2), random.randint(0,10000)) # self.noise_end_head = gr.head(gr.sizeof_gr_complex, NOISE_SAMPLES_AT_END) # blocks self.s2v = gr.stream_to_vector(gr.sizeof_char, self.vlen) self.v2s = gr.vector_to_stream(gr.sizeof_char, self.vlen) if self.ber_sink: self.ber_skipbytes0 = gr.skiphead(gr.sizeof_char, self.ber_skipbytes) self.ber_skipbytes1 = gr.skiphead(gr.sizeof_char, self.ber_skipbytes+self.dp.bytes_per_frame) # more blocks (they have state, so better reinitialise them) self.mod = dab.ofdm_mod(self.dp, debug = False) self.rescale = gr.multiply_const_cc(1) self.amp = gr.multiply_const_cc(1) self.channel = blks2.channel_model(noise_voltage=0, noise_seed=random.randint(0,10000)) # self.cat = dab.concatenate_signals(gr.sizeof_gr_complex) self.demod = dab.ofdm_demod(self.dp, self.rp, debug = False, verbose = True) # connect it all if self.ber_sink: self.connect(self.source, self.s2v, (self.mod,0), self.rescale, self.amp, self.channel, (self.demod,0), self.v2s, self.ber_skipbytes0, self.sink) self.connect(self.source, self.ber_skipbytes1, (self.sink,1)) else: self.connect(self.source, self.s2v, (self.mod,0), self.rescale, self.amp, self.channel, (self.demod,0), self.v2s, self.sink) self.connect(self.trig, (self.mod,1)) self.connect((self.demod, 1), self.trig_sink) # SNR calculation and prober self.probe_signal = gr.probe_avg_mag_sqrd_c(0,0.00001) self.probe_total = gr.probe_avg_mag_sqrd_c(0,0.00001) self.connect(self.amp, self.probe_signal) self.connect(self.channel, self.probe_total)
def clear_state(self): if self.ber_sink: self.ber_skipbytes0.rewind() self.ber_skipbytes1.rewind() # self.cat.reset() self.demod.clear_state() # TODO some state is still left in the demod block - for now just make a new one self.disconnect(self.channel, self.demod) self.disconnect((self.demod,0), self.v2s) self.disconnect((self.demod,1), self.trig_sink) self.demod = dab.ofdm_demod(self.dp, self.rp, debug = False, verbose = True) self.connect(self.channel, self.demod) self.connect((self.demod,0), self.v2s) self.connect((self.demod,1), self.trig_sink)
def __init__(self):
gr.top_block.__init__(self)
usage = "%prog: [options] samples_file"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option('-u', '--usrp-source', action="store_true", default=False,
help="Samples from USRP (-> adjust params for 2 MSPS)")
parser.add_option('-d', '--debug', action="store_true", default=False,
help="Write output to files")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="Print status messages")
(options, args) = parser.parse_args ()
if options.usrp_source:
dp = dab.dab_parameters(options.dab_mode, verbose=options.verbose, sample_rate=2000000)
else:
dp = dab.dab_parameters(options.dab_mode, verbose=options.verbose)
rp = dab.receiver_parameters(options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, correct_ffe=True, equalize_magnitude=True, verbose=options.verbose)
if len(args)<1:
print "error: need file with samples"
sys.exit(1)
else:
filename = args[0]
if options.verbose: print "--> using samples from file " + filename
self.src = gr.file_source(gr.sizeof_gr_complex, filename, False)
self.dab_demod = dab.ofdm_demod(dp, rp, verbose=options.verbose, debug=options.debug)
self.fic_dec = dab.fic_decode(dp, verbose=options.verbose, debug=options.debug)
self.connect(self.src, self.dab_demod, self.fic_dec)
self.connect((self.dab_demod,1), (self.fic_dec,1))
def __init__(self):
gr.top_block.__init__(self)
usage = "%prog: [options] samples_file"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option('-u', '--usrp-source', action="store_true", default=False,
help="Samples from USRP (-> adjust params for 2 MSPS)")
parser.add_option('-d', '--debug', action="store_true", default=False,
help="Write output to files")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="Print status messages")
(options, args) = parser.parse_args ()
if options.usrp_source:
dp = dab.dab_parameters(options.dab_mode, verbose=options.verbose, sample_rate=2000000)
else:
dp = dab.dab_parameters(options.dab_mode, verbose=options.verbose)
rp = dab.receiver_parameters(options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, correct_ffe=True, equalize_magnitude=True, verbose=options.verbose)
if len(args)<1:
print "error: need file with samples"
sys.exit(1)
else:
filename = args[0]
if options.verbose: print "--> using samples from file " + filename
self.src = gr.file_source(gr.sizeof_gr_complex, filename, False)
self.dab_demod = dab.ofdm_demod(dp, rp, verbose=options.verbose, debug=options.debug)
self.fic_dec = dab.fic_decode(dp, verbose=options.verbose, debug=options.debug)
self.connect(self.src, self.dab_demod, self.fic_dec)
self.connect((self.dab_demod,1), (self.fic_dec,1))
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
self.frame = frame
self.panel = panel
parser = OptionParser(option_class=eng_option, usage="%prog: [options] <filename>")
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option('-c', '--correct-ffe', action="store_true", default=False,
help="do fine frequency correction")
parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False,
help="do fine frequency correction by retuning the USRP instead of in software")
parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False,
help="do magnitude equalization")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0),
help="select USRP Rx side A or B [default=A]")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-r", "--sample-rate", type="int", default=2000000,
help="set sample rate to SAMPLE_RATE [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=32,
help="set decimation rate to DECIM [default=%default]")
parser.add_option("-g", "--rx-gain", type="eng_float", default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args()
self.verbose = options.verbose
self.sample_rate = options.sample_rate
if len(args) == 0:
if self.verbose:
print "--> receiving from USRP"
self.src = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.src.set_sample_rate(self.sample_rate)
# tune frequency
self.frequency = options.freq
self.set_freq(options.freq)
# set gain
if options.rx_gain is None:
# if no gain was specified, use AGC
self.src.set_gain_mode(1, 0)
else:
self.src.set_gain(options.rx_gain, 0)
else:
if self.verbose:
print "--> receiving from file: " + args[0]
self.filename = args[0]
self.src = blocks.file_source(gr.sizeof_gr_complex, self.filename, False)
self.dab_params = dab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose)
self.rx_params = dab.parameters.receiver_parameters(mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude)
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=self.verbose)
self.v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.dab_params.num_carriers)
self.scope = scopesink2.scope_sink_c(self.panel, title="DAB constellation sink", sample_rate=self.dab_params.sample_rate, xy_mode=True)
self.trigsink = blocks.null_sink(gr.sizeof_char)
self.sink = blocks.null_sink(gr.sizeof_float*self.dab_params.num_carriers*2)
self.connect(self.src, self.demod, self.sink)
self.connect((self.demod,1), self.trigsink)
# build GUI
self.connect(self.demod.deinterleave, self.v2s, self.scope)
vbox.Add(self.scope.win, 10, wx.EXPAND)
# FFT Sink
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.panel,
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=self.sample_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
vbox.Add(self.wxgui_fftsink2_0.win)
self.connect((self.src, 0), (self.wxgui_fftsink2_0, 0))
# retune USRP to correct FFE?
self.correct_ffe_usrp = options.correct_ffe_usrp
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 __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option, usage="%prog: [options] output-filename")
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option('-c', '--correct-ffe', action="store_true", default=False,
help="do fine frequency correction")
parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False,
help="do fine frequency correction by retuning the USRP instead of in software")
parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False,
help="do magnitude equalization")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-r", "--sample-rate", type="int", default=2000000,
help="set sample rate to SAMPLE_RATE [default=%default]")
parser.add_option("-g", "--rx-gain", type="eng_float", default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args ()
# if len(args)!=1:
# parser.print_help()
# sys.exit(1)
# else:
# self.filename = args[0]
# if gr.enable_realtime_scheduling() != gr.RT_OK:
# print "-> failed to enable realtime scheduling"
self.verbose = options.verbose
self.sample_rate = sample_rate = options.sample_rate
self.src = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.src.set_sample_rate(sample_rate)
#self.src.set_center_freq(209.936e6, 0)
self.src.set_freq_corr(0, 0)
self.src.set_gain_mode(1, 0)
self.src.set_gain(0, 0)
self.dab_params = dab.parameters.dab_parameters(
mode=options.dab_mode,
sample_rate=self.sample_rate,
verbose=options.verbose
)
self.rx_params = dab.parameters.receiver_parameters(
mode=options.dab_mode,
softbits=True,
input_fft_filter=options.filter_input,
autocorrect_sample_rate=options.autocorrect_sample_rate,
sample_rate_correction_factor=options.resample_fixed,
verbose=options.verbose,
correct_ffe=options.correct_ffe,
equalize_magnitude=options.equalize_magnitude
)
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=options.verbose)
if len(args) >= 1:
self.filename = args[0]
self.sink = gr.file_sink(gr.sizeof_char*12288, self.filename)
#self.sink = gr.file_sink(gr.sizeof_char*3072, self.filename)
self.connect(self.demod, self.sink)
# self.trigsink = gr.null_sink(gr.sizeof_char)
# self.connect((self.demod,1), self.trigsink)
self.fic_dec = dab.fic_decode(self.dab_params)
self.connect(self.src, self.demod, (self.fic_dec,0))
self.connect((self.demod,1), (self.fic_dec,1))
# tune frequency
self.frequency = options.freq
self.set_freq(options.freq)
# set gain
if options.rx_gain is None:
# if no gain was specified, use AGC
self.src.set_gain_mode(1, 0)
else:
self.src.set_gain(options.rx_gain, 0)
self.update_ui = options.verbose
if self.update_ui:
self.run_ui_update_thread = True
self.ui_updater = threading.Timer(0.1,self.update_ui_function)
self.ui_updater.setDaemon(True)
self.ui_updater.start()
self.correct_ffe_usrp = options.correct_ffe_usrp
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 __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option,
usage="%prog: [options] <filename>")
parser.add_option("-m",
"--dab-mode",
type="int",
default=1,
help="DAB mode [default=%default]")
parser.add_option("-F",
"--filter-input",
action="store_true",
default=False,
help="Enable FFT filter at input")
parser.add_option('-c',
'--correct-ffe',
action="store_true",
default=False,
help="do fine frequency correction")
parser.add_option(
'-u',
'--correct-ffe-usrp',
action="store_true",
default=False,
help=
"do fine frequency correction by retuning the USRP instead of in software"
)
parser.add_option('-e',
'--equalize-magnitude',
action="store_true",
default=False,
help="do magnitude equalization")
parser.add_option(
"-s",
"--resample-fixed",
type="eng_float",
default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option(
"-S",
"--autocorrect-sample-rate",
action="store_true",
default=False,
help=
"Estimate sample rate offset and resample (dynamic fractional interpolation)"
)
parser.add_option("-R",
"--rx-subdev-spec",
type="subdev",
default=(0, 0),
help="select USRP Rx side A or B [default=A]")
parser.add_option("-f",
"--freq",
type="eng_float",
default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option(
"-r",
"--sample-rate",
type="int",
default=2000000,
help="set sample rate to SAMPLE_RATE [default=%default]")
parser.add_option(
"-d",
"--decim",
type="intx",
default=32,
help="set decimation rate to DECIM [default=%default]")
parser.add_option("-g",
"--rx-gain",
type="eng_float",
default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v',
'--verbose',
action="store_true",
default=False,
help="verbose output")
(options, args) = parser.parse_args()
self.verbose = options.verbose
self.sample_rate = options.sample_rate
if len(args) == 0:
if self.verbose:
print "--> receiving from USRP"
self.src = osmosdr.source()
self.src.set_sample_rate(self.sample_rate)
self.src.set_freq_corr(0)
# tune frequency
self.frequency = options.freq
self.orig_frequency = options.freq
self.set_freq(options.freq)
self.src.set_freq_corr(0)
# set gain
if options.rx_gain is None:
# if no gain was specified, use AGC
self.src.set_gain_mode(1, 0)
else:
self.src.set_gain(options.rx_gain, 0)
else:
if self.verbose:
print "--> receiving from file: " + args[0]
self.filename = args[0]
self.src = blocks.file_source(gr.sizeof_gr_complex, self.filename,
False)
self.dab_params = dab.parameters.dab_parameters(
mode=options.dab_mode,
sample_rate=self.sample_rate,
verbose=options.verbose)
self.rx_params = dab.parameters.receiver_parameters(
mode=options.dab_mode,
softbits=True,
input_fft_filter=options.filter_input,
autocorrect_sample_rate=options.autocorrect_sample_rate,
sample_rate_correction_factor=options.resample_fixed,
verbose=options.verbose,
correct_ffe=options.correct_ffe,
equalize_magnitude=options.equalize_magnitude)
self.demod = dab.ofdm_demod(self.dab_params,
self.rx_params,
verbose=self.verbose)
self.v2s = blocks.vector_to_stream(gr.sizeof_gr_complex,
self.dab_params.num_carriers)
self.trigsink = blocks.null_sink(gr.sizeof_char)
self.sink = blocks.null_sink(gr.sizeof_float *
self.dab_params.num_carriers * 2)
self.connect(self.src, self.demod, self.sink)
self.connect((self.demod, 1), self.trigsink)
# retune USRP to correct FFE?
self.correct_ffe_usrp = options.correct_ffe_usrp
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 __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option, usage="%prog: [options] output-filename")
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option('-c', '--correct-ffe', action="store_true", default=False,
help="do fine frequency correction")
parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False,
help="do fine frequency correction by retuning the USRP instead of in software")
parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False,
help="do magnitude equalization")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-r", "--sample-rate", type="int", default=2000000,
help="set sample rate to SAMPLE_RATE [default=%default]")
parser.add_option("-g", "--rx-gain", type="eng_float", default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args ()
# if len(args)!=1:
# parser.print_help()
# sys.exit(1)
# else:
# self.filename = args[0]
# if gr.enable_realtime_scheduling() != gr.RT_OK:
# print "-> failed to enable realtime scheduling"
self.verbose = options.verbose
self.sample_rate = sample_rate = options.sample_rate
self.src = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.src.set_sample_rate(sample_rate)
#self.src.set_center_freq(209.936e6, 0)
self.src.set_freq_corr(0, 0)
self.src.set_gain_mode(1, 0)
self.src.set_gain(0, 0)
self.dab_params = dab.parameters.dab_parameters(
mode=options.dab_mode,
sample_rate=self.sample_rate,
verbose=options.verbose
)
self.rx_params = dab.parameters.receiver_parameters(
mode=options.dab_mode,
softbits=True,
input_fft_filter=options.filter_input,
autocorrect_sample_rate=options.autocorrect_sample_rate,
sample_rate_correction_factor=options.resample_fixed,
verbose=options.verbose,
correct_ffe=options.correct_ffe,
equalize_magnitude=options.equalize_magnitude
)
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=options.verbose)
if len(args) >= 1:
self.filename = args[0]
self.sink = blocks.file_sink(gr.sizeof_char*12288, self.filename)
#self.sink = gr.file_sink(gr.sizeof_char*3072, self.filename)
self.connect(self.demod, self.sink)
# self.trigsink = gr.null_sink(gr.sizeof_char)
# self.connect((self.demod,1), self.trigsink)
self.fic_dec = dab.fic_decode(self.dab_params)
self.connect(self.src, self.demod, (self.fic_dec,0))
self.connect((self.demod,1), (self.fic_dec,1))
# tune frequency
self.frequency = options.freq
self.set_freq(options.freq)
# set gain
if options.rx_gain is None:
# if no gain was specified, use AGC
self.src.set_gain_mode(1, 0)
else:
self.src.set_gain(options.rx_gain, 0)
self.update_ui = options.verbose
if self.update_ui:
self.run_ui_update_thread = True
self.ui_updater = threading.Timer(0.1,self.update_ui_function)
self.ui_updater.setDaemon(True)
self.ui_updater.start()
self.correct_ffe_usrp = options.correct_ffe_usrp
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 __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option, usage="%prog: [options] <filename>")
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option('-c', '--correct-ffe', action="store_true", default=False,
help="do fine frequency correction")
parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False,
help="do fine frequency correction by retuning the USRP instead of in software")
parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False,
help="do magnitude equalization")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0),
help="select USRP Rx side A or B [default=A]")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-r", "--sample-rate", type="int", default=2000000,
help="set sample rate to SAMPLE_RATE [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=32,
help="set decimation rate to DECIM [default=%default]")
parser.add_option("-g", "--rx-gain", type="eng_float", default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args()
self.verbose = options.verbose
self.sample_rate = options.sample_rate
if len(args) == 0:
if self.verbose:
print "--> receiving from USRP"
self.src = osmosdr.source()
self.src.set_sample_rate(self.sample_rate)
self.src.set_freq_corr(0)
# tune frequency
self.frequency = options.freq
self.orig_frequency = options.freq
self.set_freq(options.freq)
self.src.set_freq_corr(0)
# set gain
if options.rx_gain is None:
# if no gain was specified, use AGC
self.src.set_gain_mode(1, 0)
else:
self.src.set_gain(options.rx_gain, 0)
else:
if self.verbose:
print "--> receiving from file: " + args[0]
self.filename = args[0]
self.src = blocks.file_source(gr.sizeof_gr_complex, self.filename, False)
self.dab_params = dab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose)
self.rx_params = dab.parameters.receiver_parameters(mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude)
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=self.verbose)
self.v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.dab_params.num_carriers)
self.trigsink = blocks.null_sink(gr.sizeof_char)
self.sink = blocks.null_sink(gr.sizeof_float*self.dab_params.num_carriers*2)
self.connect(self.src, self.demod, self.sink)
self.connect((self.demod,1), self.trigsink)
# retune USRP to correct FFE?
self.correct_ffe_usrp = options.correct_ffe_usrp
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 __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option, usage="%prog: [options] output-filename")
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option('-c', '--correct-ffe', action="store_true", default=False,
help="do fine frequency correction")
parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False,
help="do fine frequency correction by retuning the USRP instead of in software")
parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False,
help="do magnitude equalization")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0),
help="select USRP Rx side A or B [default=A]")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=32,
help="set decimation rate to DECIM [default=%default]")
parser.add_option("-g", "--rx-gain", type="eng_float", default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args ()
# if len(args)!=1:
# parser.print_help()
# sys.exit(1)
# else:
# self.filename = args[0]
# if gr.enable_realtime_scheduling() != gr.RT_OK:
# print "-> failed to enable realtime scheduling"
self.verbose = options.verbose
self.src = usrp.source_c(decim_rate=options.decim)
self.src.set_mux(usrp.determine_rx_mux_value(self.src, options.rx_subdev_spec))
self.subdev = usrp.selected_subdev(self.src, options.rx_subdev_spec)
print "--> using RX dboard " + self.subdev.side_and_name()
self.sample_rate = self.src.adc_rate()/options.decim
self.dab_params = dab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose)
self.rx_params = dab.parameters.receiver_parameters(mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude)
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=options.verbose)
# self.sink = gr.file_sink(gr.sizeof_char*384, self.filename)
# self.trigsink = gr.null_sink(gr.sizeof_char)
# self.connect(self.src, self.demod, self.sink)
# self.connect((self.demod,1), self.trigsink)
self.fic_dec = dab.fic_decode(self.dab_params)
self.connect(self.src, self.demod, (self.fic_dec,0))
self.connect((self.demod,1), (self.fic_dec,1))
# tune frequency
self.frequency = options.freq
self.set_freq(options.freq)
# set gain
if options.rx_gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
options.rx_gain = float(g[0]+g[1])/2
self.subdev.set_gain(options.rx_gain)
self.update_ui = options.verbose
if self.update_ui:
self.run_ui_update_thread = True
self.ui_updater = threading.Timer(0.1,self.update_ui_function)
self.ui_updater.setDaemon(True)
self.ui_updater.start()
self.correct_ffe_usrp = options.correct_ffe_usrp
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 __init__(self,
dab_mode,
frequency,
bit_rate,
address,
size,
protection,
audio_bit_rate,
dabplus,
use_usrp,
src_path,
sink_path="None"):
gr.top_block.__init__(self)
self.dab_mode = dab_mode
self.verbose = False
self.sample_rate = 2e6
self.dabplus = dabplus
self.use_usrp = use_usrp
self.src_path = src_path
self.sink_path = sink_path
gr.log.set_level("warn")
########################
# source
########################
if self.use_usrp:
self.src = uhd.usrp_source("", uhd.io_type.COMPLEX_FLOAT32, 1)
self.src.set_samp_rate(self.sample_rate)
self.src.set_antenna("TX/RX")
else:
print "using file source"
self.src = blocks.file_source_make(gr.sizeof_gr_complex,
self.src_path, False)
# set paramters to default mode
self.softbits = True
self.filter_input = True
self.autocorrect_sample_rate = False
self.resample_fixed = 1
self.correct_ffe = True
self.equalize_magnitude = True
self.frequency = frequency
self.dab_params = dab.parameters.dab_parameters(
self.dab_mode, self.sample_rate, self.verbose)
self.rx_params = dab.parameters.receiver_parameters(
self.dab_mode, self.softbits, self.filter_input,
self.autocorrect_sample_rate, self.resample_fixed, self.verbose,
self.correct_ffe, self.equalize_magnitude)
########################
# FFT and waterfall plot
########################
self.fft_plot = qtgui.freq_sink_c_make(1024,
fft.window.WIN_BLACKMAN_HARRIS,
self.frequency, 2e6, "FFT")
self.waterfall_plot = qtgui.waterfall_sink_c_make(
1024, fft.window.WIN_BLACKMAN_HARRIS, self.frequency, 2e6,
"Waterfall")
#self.time_plot = qtgui.time_sink_c_make(1024, 2e6, "Time")
########################
# OFDM demod
########################
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params,
self.verbose)
########################
# SNR measurement
########################
self.v2s_snr = blocks.vector_to_stream_make(
gr.sizeof_gr_complex, self.dab_params.num_carriers)
self.snr_measurement = digital.mpsk_snr_est_cc_make(
digital.SNR_EST_SIMPLE, 10000)
self.constellation_plot = qtgui.const_sink_c_make(1024, "", 1)
########################
# FIC decoder
########################
self.fic_dec = dab.fic_decode(self.dab_params)
########################
# MSC decoder
########################
if self.dabplus:
self.dabplus = dab.dabplus_audio_decoder_ff(
self.dab_params, bit_rate, address, size, protection, True)
else:
self.msc_dec = dab.msc_decode(self.dab_params, address, size,
protection)
self.unpack = blocks.packed_to_unpacked_bb_make(1, gr.GR_MSB_FIRST)
self.mp2_dec = dab.mp2_decode_bs_make(bit_rate / 8)
self.s2f_left = blocks.short_to_float_make(1, 32767)
self.s2f_right = blocks.short_to_float_make(1, 32767)
self.gain_left = blocks.multiply_const_ff(1, 1)
self.gain_right = blocks.multiply_const_ff(1, 1)
########################
# audio sink
########################
self.valve_left = dab.valve_ff_make(True)
self.valve_right = dab.valve_ff_make(True)
self.audio = audio.sink_make(audio_bit_rate)
self.wav_sink = blocks.wavfile_sink_make("dab_audio.wav", 2,
audio_bit_rate)
########################
# Connections
########################
self.connect(self.src, self.fft_plot)
self.connect(self.src, self.waterfall_plot)
self.connect(self.src, self.demod, (self.fic_dec, 0))
self.connect((self.demod, 1), (self.fic_dec, 1))
if self.dabplus:
self.connect((self.demod, 0), (self.dabplus, 0))
self.connect((self.demod, 1), (self.dabplus, 1))
else:
self.connect((self.demod, 0), (self.msc_dec, 0), self.unpack,
self.mp2_dec)
self.connect((self.demod, 1), (self.msc_dec, 1))
self.connect((self.mp2_dec, 0), self.s2f_left, self.gain_left)
self.connect((self.mp2_dec, 1), self.s2f_right, self.gain_right)
self.connect((self.demod, 0), self.v2s_snr, self.snr_measurement,
self.constellation_plot)
# connect audio to sound card and file sink
if self.dabplus:
self.connect((self.dabplus, 0), (self.audio, 0))
self.connect((self.dabplus, 1), (self.audio, 1))
self.connect((self.dabplus, 0), self.valve_left,
(self.wav_sink, 0))
self.connect((self.dabplus, 1), self.valve_right,
(self.wav_sink, 1))
else:
self.connect(self.gain_left, (self.audio, 0))
self.connect(self.gain_right, (self.audio, 1))
self.connect(self.gain_left, self.valve_left, (self.wav_sink, 0))
self.connect(self.gain_right, self.valve_right, (self.wav_sink, 1))
# tune USRP frequency
if self.use_usrp:
self.set_freq(self.frequency)
# set gain
# if no gain was specified, use the mid-point in dB
g = self.src.get_gain_range()
self.rx_gain = float(g.start() + g.stop()) / 2
self.src.set_gain(self.rx_gain)
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
self.frame = frame
self.panel = panel
parser = OptionParser(option_class=eng_option, usage="%prog: [options] <filename>")
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option('-c', '--correct-ffe', action="store_true", default=False,
help="do fine frequency correction")
parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False,
help="do fine frequency correction by retuning the USRP instead of in software")
parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False,
help="do magnitude equalization")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0),
help="select USRP Rx side A or B [default=A]")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-r", "--sample-rate", type="int", default=2000000,
help="set sample rate to SAMPLE_RATE [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=32,
help="set decimation rate to DECIM [default=%default]")
parser.add_option("-g", "--rx-gain", type="eng_float", default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args()
self.verbose = options.verbose
if len(args) == 0:
if self.verbose:
print "--> receiving from USRP"
self.src = usrp.source_c(decim_rate=options.decim)
self.src.set_mux(usrp.determine_rx_mux_value(self.src, options.rx_subdev_spec))
self.subdev = usrp.selected_subdev(self.src, options.rx_subdev_spec)
if self.verbose:
print "--> using RX dboard " + self.subdev.side_and_name()
# tune frequency
self.frequency = options.freq
self.set_freq(options.freq)
# set gain
if options.rx_gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
options.rx_gain = float(g[0]+g[1])/2
self.subdev.set_gain(options.rx_gain)
self.sample_rate = self.src.adc_rate()/options.decim
else:
if self.verbose:
print "--> receiving from file: " + args[0]
self.filename = args[0]
self.src = gr.file_source(gr.sizeof_gr_complex, self.filename, False)
self.sample_rate = options.sample_rate
self.dab_params = dab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose)
self.rx_params = dab.parameters.receiver_parameters(mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude)
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=self.verbose)
self.v2s = gr.vector_to_stream(gr.sizeof_gr_complex, self.dab_params.num_carriers)
self.scope = scopesink2.scope_sink_c(self.panel, title="DAB constellation sink", sample_rate=self.dab_params.sample_rate, xy_mode=True)
self.trigsink = gr.null_sink(gr.sizeof_char)
self.sink = gr.null_sink(gr.sizeof_float*self.dab_params.num_carriers*2)
self.connect(self.src, self.demod, self.sink)
self.connect((self.demod,1), self.trigsink)
# build GUI
self.connect(self.demod.deinterleave, self.v2s, self.scope)
vbox.Add(self.scope.win, 10, wx.EXPAND)
# retune USRP to correct FFE?
self.correct_ffe_usrp = options.correct_ffe_usrp
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 __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option,
usage="%prog: [options] output-filename")
parser.add_option("-m",
"--dab-mode",
type="int",
default=1,
help="DAB mode [default=%default]")
parser.add_option("-F",
"--filter-input",
action="store_true",
default=False,
help="Enable FFT filter at input")
parser.add_option('-c',
'--correct-ffe',
action="store_true",
default=False,
help="do fine frequency correction")
parser.add_option(
'-u',
'--correct-ffe-usrp',
action="store_true",
default=False,
help=
"do fine frequency correction by retuning the USRP instead of in software"
)
parser.add_option('-e',
'--equalize-magnitude',
action="store_true",
default=False,
help="do magnitude equalization")
parser.add_option(
"-s",
"--resample-fixed",
type="eng_float",
default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option(
"-S",
"--autocorrect-sample-rate",
action="store_true",
default=False,
help=
"Estimate sample rate offset and resample (dynamic fractional interpolation)"
)
parser.add_option("-R",
"--rx-subdev-spec",
type="subdev",
default=(0, 0),
help="select USRP Rx side A or B [default=A]")
parser.add_option("-f",
"--freq",
type="eng_float",
default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option(
"-d",
"--decim",
type="intx",
default=32,
help="set decimation rate to DECIM [default=%default]")
parser.add_option("-g",
"--rx-gain",
type="eng_float",
default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v',
'--verbose',
action="store_true",
default=False,
help="verbose output")
parser.add_option('-a',
'--antenna',
type="string",
default="TX/RX",
help="select antenna")
(options, args) = parser.parse_args()
# if len(args)!=1:
# parser.print_help()
# sys.exit(1)
# else:
# self.filename = args[0]
# if gr.enable_realtime_scheduling() != gr.RT_OK:
# print "-> failed to enable realtime scheduling"
self.verbose = options.verbose
self.src = uhd.usrp_source("", uhd.io_type.COMPLEX_FLOAT32, 1)
#self.src.set_mux(usrp.determine_rx_mux_value(self.src, options.rx_subdev_spec))
#self.subdev = uhd.selected_subdev(self.src, options.rx_subdev_spec)
#print "--> using RX dboard " + self.subdev.side_and_name()
self.sample_rate = 2e6 #self.src.adc_rate()/options.decim
self.src.set_samp_rate(self.sample_rate)
self.src.set_antenna(options.antenna)
self.dab_params = dab.parameters.dab_parameters(
mode=options.dab_mode,
sample_rate=self.sample_rate,
verbose=options.verbose)
self.rx_params = dab.parameters.receiver_parameters(
mode=options.dab_mode,
softbits=True,
input_fft_filter=options.filter_input,
autocorrect_sample_rate=options.autocorrect_sample_rate,
sample_rate_correction_factor=options.resample_fixed,
verbose=options.verbose,
correct_ffe=options.correct_ffe,
equalize_magnitude=options.equalize_magnitude)
self.demod = dab.ofdm_demod(self.dab_params,
self.rx_params,
verbose=options.verbose)
# self.sink = gr.file_sink(gr.sizeof_char*384, self.filename)
# self.trigsink = gr.null_sink(gr.sizeof_char)
# self.connect(self.src, self.demod, self.sink)
# self.connect((self.demod,1), self.trigsink)
self.fic_dec = dab.fic_decode(self.dab_params)
self.connect(self.src, self.demod, (self.fic_dec, 0))
self.connect((self.demod, 1), (self.fic_dec, 1))
# tune frequency
self.frequency = options.freq
self.set_freq(options.freq)
# set gain
if options.rx_gain is None:
# if no gain was specified, use the mid-point in dB
g = self.src.get_gain_range()
options.rx_gain = float(g.start() + g.stop()) / 2
self.src.set_gain(options.rx_gain)
#self.subdev.set_gain(options.rx_gain)
self.update_ui = options.verbose
if self.update_ui:
self.run_ui_update_thread = True
self.ui_updater = threading.Timer(0.1, self.update_ui_function)
self.ui_updater.setDaemon(True)
self.ui_updater.start()
self.correct_ffe_usrp = options.correct_ffe_usrp
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 __init__(self, frequency, bit_rate, address, size, protection, use_usrp, src_path, record_audio = False, sink_path = "None"):
gr.top_block.__init__(self)
self.dab_mode = 1
self.verbose = False
self.sample_rate = 2e6
self.use_usrp = use_usrp
self.src_path = src_path
self.record_audio = record_audio
self.sink_path = sink_path
########################
# source
########################
if self.use_usrp:
self.src = uhd.usrp_source("", uhd.io_type.COMPLEX_FLOAT32, 1)
self.src.set_samp_rate(self.sample_rate)
self.src.set_antenna("TX/RX")
else:
print "using file source"
self.src = blocks.file_source_make(gr.sizeof_gr_complex, self.src_path, True)
# set paramters to default mode
self.softbits = True
self.filter_input = True
self.autocorrect_sample_rate = False
self.resample_fixed = 1
self.correct_ffe = True
self.equalize_magnitude = True
self.frequency = frequency
self.dab_params = dab.parameters.dab_parameters(self.dab_mode, self.sample_rate, self.verbose)
self.rx_params = dab.parameters.receiver_parameters(self.dab_mode, self.softbits,
self.filter_input,
self.autocorrect_sample_rate,
self.resample_fixed,
self.verbose, self.correct_ffe,
self.equalize_magnitude)
########################
# OFDM demod
########################
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, self.verbose)
########################
# SNR measurement
########################
self.v2s_snr = blocks.vector_to_stream_make(gr.sizeof_gr_complex, 1536)
self.snr_measurement = digital.mpsk_snr_est_cc_make(digital.SNR_EST_SIMPLE, 10000)
self.null_sink_snr = blocks.null_sink_make(gr.sizeof_gr_complex)
########################
# FIC decoder
########################
self.fic_dec = dab.fic_decode(self.dab_params)
########################
# MSC decoder and audio sink
########################
self.dabplus = dab.dabplus_audio_decoder_ff(self.dab_params, bit_rate, address, size, protection, True)
self.audio = audio.sink_make(32000)
########################
# Connections
########################
self.connect(self.src, self.demod, (self.fic_dec, 0))
self.connect((self.demod, 1), (self.fic_dec, 1))
self.connect((self.demod, 0), (self.dabplus, 0))
self.connect((self.demod, 1), (self.dabplus, 1))
self.connect((self.demod, 0), self.v2s_snr, self.snr_measurement, self.null_sink_snr)
# connect audio to sound card
# left stereo channel
self.connect((self.dabplus, 0), (self.audio, 0))
# right stereo channel
self.connect((self.dabplus, 1), (self.audio, 1))
# connect file sink if recording is selected
if self.record_audio:
self.sink = blocks.wavfile_sink_make("dab_audio.wav", 2, 32000)
self.connect((self.dabplus, 0), (self.sink, 0))
self.connect((self.dabplus, 1), (self.sink, 1))
# tune USRP frequency
if self.use_usrp:
self.set_freq(self.frequency)
# set gain
# if no gain was specified, use the mid-point in dB
g = self.src.get_gain_range()
self.rx_gain = float(g.start() + g.stop()) / 2
self.src.set_gain(self.rx_gain)
