def __init__(self, fg, noise_voltage=0.0, frequency_offset=0.0, epsilon=1.0, taps=[1.0,0.0]):
''' Creates a channel model that includes:
- AWGN noise power in terms of noise voltage
- A frequency offest in the channel in ratio
- A timing offset ratio to model clock difference (epsilon)
- Multipath taps
'''
print epsilon
self.timing_offset = gr.fractional_interpolator_cc(0, epsilon)
self.multipath = gr.fir_filter_ccc(1, taps)
self.noise_adder = gr.add_cc()
self.noise = gr.noise_source_c(gr.GR_GAUSSIAN,noise_voltage)
self.freq_offset = gr.sig_source_c(1, gr.GR_SIN_WAVE, frequency_offset, 1.0, 0.0)
self.mixer_offset = gr.multiply_cc()
fg.connect(self.timing_offset, self.multipath)
fg.connect(self.multipath, (self.mixer_offset,0))
fg.connect(self.freq_offset,(self.mixer_offset,1))
fg.connect(self.mixer_offset, (self.noise_adder,1))
fg.connect(self.noise, (self.noise_adder,0))
gr.hier_block.__init__(self, fg, self.timing_offset, self.noise_adder)
def __init__(self, noise_voltage=0.0, frequency_offset=0.0, epsilon=1.0, taps=[1.0,0.0], noise_seed=3021):
''' Creates a channel model that includes:
- AWGN noise power in terms of noise voltage
- A frequency offest in the channel in ratio
- A timing offset ratio to model clock difference (epsilon)
- Multipath taps
'''
gr.hier_block2.__init__(self, "channel_model",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
#print epsilon
self.timing_offset = gr.fractional_interpolator_cc(0, epsilon)
self.multipath = gr.fir_filter_ccc(1, taps)
self.noise_adder = gr.add_cc()
self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, noise_voltage, noise_seed)
self.freq_offset = gr.sig_source_c(1, gr.GR_SIN_WAVE, frequency_offset, 1.0, 0.0)
self.mixer_offset = gr.multiply_cc()
self.connect(self, self.timing_offset, self.multipath)
self.connect(self.multipath, (self.mixer_offset,0))
self.connect(self.freq_offset,(self.mixer_offset,1))
self.connect(self.mixer_offset, (self.noise_adder,1))
self.connect(self.noise, (self.noise_adder,0))
self.connect(self.noise_adder, self)
def __init__(self, samplerate, symbolrate = SYMRATE, channel_str = None, sendmsg = True, debug = False, samplepersymbol = SPS, fmdeviation = FM_DEVIATION ): gr.hier_block2.__init__(self, "pocsag", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, 1)) self.samplerate = samplerate self.symbolrate = symbolrate self.sendmsg = sendmsg self.debug = debug self.samplepersymbol = samplepersymbol self.fmdeviation = fmdeviation self.fractional_interpolator = gr.fractional_interpolator_cc(0, 1.0 * samplerate / (symbolrate * samplepersymbol)) self.quadrature_demod = gr.quadrature_demod_cf((symbolrate * samplepersymbol) / (fmdeviation * 4.0)) self.low_pass_filter = gr.fir_filter_fff(1, gr.firdes.low_pass(1, symbolrate * samplepersymbol, symbolrate * 2, symbolrate / 2.0, gr.firdes.WIN_HAMMING, 6.76)) self.digital_clock_recovery_mm = digital.clock_recovery_mm_ff(samplepersymbol, 0.03 * 0.03 * 0.3, 0.4, 0.03, 1e-4) self.digital_binary_slicer_fb = digital.binary_slicer_fb() self.pktdecoder = pocsag_pktdecoder(channel_str = channel_str, sendmsg = sendmsg, debug = debug) self.connect(self, self.fractional_interpolator, self.quadrature_demod, self.low_pass_filter, self.digital_clock_recovery_mm, self.digital_binary_slicer_fb, self.pktdecoder, self)
def gsm_receiver( self, input_rate = 400e3):
filter_cutoff = 145e3
filter_t_width = 10e3
offset = 0
#rates
gsm_symb_rate = 1625000.0 / 6.0
sps = input_rate / gsm_symb_rate / self.options.osr
filter_taps = gr.firdes.low_pass(1.0, input_rate, filter_cutoff, filter_t_width, gr.firdes.WIN_HAMMING)
filtr = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset, input_rate)
interpolator = gr.fractional_interpolator_cc(0, sps)
tuner_callback = tuner(filtr)
synchronizer_callback = synchronizer(self)
receiver = gsm.receiver_cf( tuner_callback, synchronizer_callback, self.options.osr, self.options.key.replace(' ', '').lower(), self.options.configuration.upper())
blocks = {}
blocks[ "synchronizer_callback"] = synchronizer_callback
blocks[ "tuner_callback"] = tuner_callback
blocks[ "filter_taps"] = filter_taps
blocks[ "filtr"] = filtr
blocks[ "interpolator"] = interpolator
blocks[ "receiver"] = receiver
self.connect( filtr, interpolator, receiver)
return blocks, filtr
def __init__(self,
N,
sps,
rolloff,
ntaps,
bw,
noise,
foffset,
toffset,
poffset,
mode=0):
gr.top_block.__init__(self)
rrc_taps = gr.firdes.root_raised_cosine(sps, sps, 1.0, rolloff, ntaps)
gain = 2 * scipy.pi / 100.0
nfilts = 32
rrc_taps_rx = gr.firdes.root_raised_cosine(nfilts, sps * nfilts, 1.0,
rolloff, ntaps * nfilts)
data = 2.0 * scipy.random.randint(0, 2, N) - 1.0
data = scipy.exp(1j * poffset) * data
self.src = gr.vector_source_c(data.tolist(), False)
self.rrc = gr.interp_fir_filter_ccf(sps, rrc_taps)
self.chn = gr.channel_model(noise, foffset, toffset)
self.off = gr.fractional_interpolator_cc(0.20, 1.0)
if mode == 0:
self.clk = gr.pfb_clock_sync_ccf(sps, gain, rrc_taps_rx, nfilts,
nfilts // 2, 3.5)
self.taps = self.clk.get_taps()
self.dtaps = self.clk.get_diff_taps()
self.vsnk_err = gr.vector_sink_f()
self.vsnk_rat = gr.vector_sink_f()
self.vsnk_phs = gr.vector_sink_f()
self.connect((self.clk, 1), self.vsnk_err)
self.connect((self.clk, 2), self.vsnk_rat)
self.connect((self.clk, 3), self.vsnk_phs)
else: # mode == 1
mu = 0.5
gain_mu = 0.1
gain_omega = 0.25 * gain_mu * gain_mu
omega_rel_lim = 0.02
self.clk = digital.clock_recovery_mm_cc(sps, gain_omega, mu,
gain_mu, omega_rel_lim)
self.vsnk_err = gr.vector_sink_f()
self.connect((self.clk, 1), self.vsnk_err)
self.vsnk_src = gr.vector_sink_c()
self.vsnk_clk = gr.vector_sink_c()
self.connect(self.src, self.rrc, self.chn, self.off, self.clk,
self.vsnk_clk)
self.connect(self.off, self.vsnk_src)
def __init__(self):
#grc_wxgui.top_block_gui.__init__(self, title="Top Block")
gr.top_block.__init__(self)
print "abc"
##################################################
# Variables
##################################################
#self.samp_rate = samp_rate = 32000
self.osr = 4
self.key = ''
self.configuration = ''
self.clock_rate = 52e6
self.input_rate = self.clock_rate / 72 #TODO: what about usrp value?
self.gsm_symb_rate = 1625000.0 / 6.0
self.sps = self.input_rate / self.gsm_symb_rate
# configure channel filter
filter_cutoff = 135e3 #135,417Hz is GSM bandwidth
filter_t_width = 10e3
offset = 0.0
##################################################
# Blocks
##################################################
self.gr_null_sink_0 = gr.null_sink(gr.sizeof_gr_complex*1)
print "Input files: ", downfile, " ", upfile
self.gr_file_source_0 = gr.file_source(gr.sizeof_gr_complex*1, downfile, False)
self.gr_file_source_1 = gr.file_source(gr.sizeof_gr_complex*1, upfile, False)
filter_taps = gr.firdes.low_pass(1.0, self.input_rate, filter_cutoff, filter_t_width, gr.firdes.WIN_HAMMING)
print len(filter_taps)
self.filter0 = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset, self.input_rate)
self.filter1 = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset, self.input_rate)
self.interpolator_1 = gr.fractional_interpolator_cc(0, self.sps)
self.tuner_callback = tuner(self)
self.synchronizer_callback = synchronizer(self)
#self.buffer = howto.buffer_cc()
self.burst_cb = burst_callback(self)
print ">>>>>Input rate: ", self.input_rate
#self.burst = gsm.burst_cf(self.burst_cb,self.input_rate)
self.receiver = gsm.receiver_cf(self.tuner_callback, self.synchronizer_callback, self.osr, self.key.replace(' ', '').lower(), self.configuration.upper())
##################################################
# Connections
##################################################
#self.connect((self.gr_file_source_0, 0), (self.filter0, 0), (self.burst, 0))
self.connect((self.gr_file_source_1, 0), (self.filter1, 0), (self.interpolator_1, 0), (self.receiver, 0))
def __init__(self, options):
gr.top_block.__init__(self)
# Create a USRP2 source and set decimation rate
self._u = usrp2.source_32fc(options.interface, options.mac_addr)
self._u.set_decim(512)
# Set receive daughterboard gain
if options.gain is None:
g = self._u.gain_range()
options.gain = float(g[0] + g[1]) / 2
print "Using mid-point gain of", options.gain, "(", g[0], "-", g[
1], ")"
self._u.set_gain(options.gain)
# Set receive frequency
if options.lo_offset is not None:
self._u.set_lo_offset(options.lo_offset)
tr = self._u.set_center_freq(options.freq)
if tr == None:
sys.stderr.write('Failed to set center frequency\n')
raise SystemExit, 1
sample_rate = 100e6 / 512
symbol_rate = 18000
sps = 2
# output rate will be 36,000
ntaps = 11 * sps
new_sample_rate = symbol_rate * sps
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass,
options.low_pass * 0.1,
gr.firdes.WIN_HANN)
FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps,
options.calibration,
sample_rate)
sys.stderr.write("sample rate: %d\n" % (sample_rate))
DEMOD = cqpsk.cqpsk_demod(samples_per_symbol=sps,
excess_bw=0.35,
costas_alpha=0.03,
gain_mu=0.05,
mu=0.05,
omega_relative_limit=0.05,
log=options.log,
verbose=options.verbose)
OUT = gr.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = gr.fractional_interpolator_cc(0, r)
self.connect(self._u, FILTER, INTERPOLATOR, DEMOD, OUT)
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
self.frame = frame
self.panel = panel
options = get_options()
sample_rate = int(options.sample_rate)
self.asrc = audio.source(sample_rate, options.audio_device, True)
self.f2c = gr.float_to_complex(1)
self.connect((self.asrc, 1), (self.f2c, 1))
self.connect((self.asrc, 0), (self.f2c, 0))
symbol_rate = 18000
sps = 2
# output rate will be 36,000
ntaps = 11 * sps
new_sample_rate = symbol_rate * sps
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, gr.firdes.WIN_HANN)
FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps, options.calibration, sample_rate)
sys.stderr.write("sample rate: %d\n" %(sample_rate))
DEMOD = cqpsk.cqpsk_demod( samples_per_symbol = sps,
excess_bw=0.35,
costas_alpha=0.03,
gain_mu=0.05,
mu=0.05,
omega_relative_limit=0.05,
log=options.log,
verbose=options.verbose)
OUT = gr.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = gr.fractional_interpolator_cc(0, r)
self.connect(self.f2c, FILTER, INTERPOLATOR, DEMOD, OUT)
self.scope = fftsink2.fft_sink_c(panel, fft_size=512,
sample_rate=sample_rate,
ref_scale=2.0,
ref_level=-30, y_divs=10,
fft_rate=10,
average=True,
avg_alpha=0.2)
self.connect(self.f2c, self.scope)
def __init__(self, N, sps, rolloff, ntaps, bw, noise,
foffset, toffset, poffset, mode=0):
gr.top_block.__init__(self)
rrc_taps = gr.firdes.root_raised_cosine(
sps, sps, 1.0, rolloff, ntaps)
gain = 2*scipy.pi/100.0
nfilts = 32
rrc_taps_rx = gr.firdes.root_raised_cosine(
nfilts, sps*nfilts, 1.0, rolloff, ntaps*nfilts)
data = 2.0*scipy.random.randint(0, 2, N) - 1.0
data = scipy.exp(1j*poffset) * data
self.src = gr.vector_source_c(data.tolist(), False)
self.rrc = gr.interp_fir_filter_ccf(sps, rrc_taps)
self.chn = gr.channel_model(noise, foffset, toffset)
self.off = gr.fractional_interpolator_cc(0.20, 1.0)
if mode == 0:
self.clk = gr.pfb_clock_sync_ccf(sps, gain, rrc_taps_rx,
nfilts, nfilts//2, 3.5)
self.taps = self.clk.get_taps()
self.dtaps = self.clk.get_diff_taps()
self.vsnk_err = gr.vector_sink_f()
self.vsnk_rat = gr.vector_sink_f()
self.vsnk_phs = gr.vector_sink_f()
self.connect((self.clk,1), self.vsnk_err)
self.connect((self.clk,2), self.vsnk_rat)
self.connect((self.clk,3), self.vsnk_phs)
else: # mode == 1
mu = 0.5
gain_mu = 0.1
gain_omega = 0.25*gain_mu*gain_mu
omega_rel_lim = 0.02
self.clk = digital.clock_recovery_mm_cc(sps, gain_omega,
mu, gain_mu,
omega_rel_lim)
self.vsnk_err = gr.vector_sink_f()
self.connect((self.clk,1), self.vsnk_err)
self.vsnk_src = gr.vector_sink_c()
self.vsnk_clk = gr.vector_sink_c()
self.connect(self.src, self.rrc, self.chn, self.off, self.clk, self.vsnk_clk)
self.connect(self.off, self.vsnk_src)
def __init__(self, options):
gr.top_block.__init__(self)
# Create a USRP2 source and set decimation rate
self._u = usrp2.source_32fc(options.interface, options.mac_addr)
self._u.set_decim(512)
# Set receive daughterboard gain
if options.gain is None:
g = self._u.gain_range()
options.gain = float(g[0]+g[1])/2
print "Using mid-point gain of", options.gain, "(", g[0], "-", g[1], ")"
self._u.set_gain(options.gain)
# Set receive frequency
if options.lo_offset is not None:
self._u.set_lo_offset(options.lo_offset)
tr = self._u.set_center_freq(options.freq)
if tr == None:
sys.stderr.write('Failed to set center frequency\n')
raise SystemExit, 1
sample_rate = 100e6/512
symbol_rate = 18000
sps = 2
# output rate will be 36,000
ntaps = 11 * sps
new_sample_rate = symbol_rate * sps
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, gr.firdes.WIN_HANN)
FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps, options.calibration, sample_rate)
sys.stderr.write("sample rate: %d\n" %(sample_rate))
DEMOD = cqpsk.cqpsk_demod( samples_per_symbol = sps,
excess_bw=0.35,
costas_alpha=0.03,
gain_mu=0.05,
mu=0.05,
omega_relative_limit=0.05,
log=options.log,
verbose=options.verbose)
OUT = gr.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = gr.fractional_interpolator_cc(0, r)
self.connect(self._u, FILTER, INTERPOLATOR, DEMOD, OUT)
def __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option)
parser.add_option("-c", "--calibration", type="eng_float", default=0, help="freq offset")
parser.add_option("-i", "--input-file", type="string", default="in.dat", help="specify the input file")
parser.add_option("-l", "--log", 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.dat", help="specify the output file")
parser.add_option("-s", "--sample-rate", type="int", default=100000000/512, help="input sample rate")
parser.add_option("-v", "--verbose", action="store_true", default=False, help="dump demodulation data")
(options, args) = parser.parse_args()
sample_rate = options.sample_rate
symbol_rate = 18000
sps = 2
# output rate will be 36,000
ntaps = 11 * sps
new_sample_rate = symbol_rate * sps
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, gr.firdes.WIN_HANN)
FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps, options.calibration, sample_rate)
sys.stderr.write("sample rate: %d\n" %(sample_rate))
IN = gr.file_source(gr.sizeof_gr_complex, options.input_file)
DEMOD = cqpsk.cqpsk_demod( samples_per_symbol = sps,
excess_bw=0.35,
costas_alpha=0.03,
gain_mu=0.05,
mu=0.05,
omega_relative_limit=0.05,
log=options.log,
verbose=options.verbose)
OUT = gr.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = gr.fractional_interpolator_cc(0, r)
self.connect(IN, FILTER, INTERPOLATOR, DEMOD, OUT)
def resetapp(void):
pre_status = getServerStatus()
if getServerStatus() == True:
setServerStatus(False)
self.serverlabel_state.SetLabel("Not Connected:")
self.btnstart_server.SetLabel("Start Server")
time.sleep(0.2)
tb.stop()
tb.wait()
self.disconnect(self.src, self.tuner, self.interpolator,self.receiver, self.converter, self.output)
sample_rate = self.src.get_sample_rate()
sys.stderr.write("sample rate: %d\n" % (sample_rate))
gsm_symb_rate = 1625000.0 / 6.0
sps = sample_rate / gsm_symb_rate / 4
out_sample_rate = gsm_symb_rate * 4
self.offset = 0
taps = gr.firdes.low_pass(1.0, sample_rate, 145e3, 10e3, gr.firdes.WIN_HANN)
self.tuner = gr.freq_xlating_fir_filter_ccf(1, taps, self.offset, sample_rate)
self.interpolator = gr.fractional_interpolator_cc(0, sps)
#channel type
options.configuration = self.channel_combo_box.get_value()
#use key or not
options.key = "0000000000000000"#use this as default
if self.cb_imsi.GetValue() == True:
options.key = str(self.edit_key.GetValue())
self.receiver = gsm.receiver_cf(
self.tune_corrector_callback, self.synchronizer_callback, 4,
options.key.replace(' ', '').lower(),
options.configuration.upper())
self.output = gr.file_sink(gr.sizeof_float, options.output_file)
#self.interpolator, self.receiver,
self.connect(self.src, self.tuner, self.interpolator,self.receiver, self.converter, self.output)
#ending
time.sleep(0.3)
tb.Run(True)
def __init__(self, options):
gr.top_block.__init__(self)
sample_rate = int(options.sample_rate)
self.asrc = audio.source(sample_rate, options.audio_device, True)
self.f2c = gr.float_to_complex(1)
self.connect((self.asrc, 1), (self.f2c, 1))
self.connect((self.asrc, 0), (self.f2c, 0))
symbol_rate = 18000
sps = 2
# output rate will be 36,000
ntaps = 11 * sps
new_sample_rate = symbol_rate * sps
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, gr.firdes.WIN_HANN)
FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps, options.calibration, sample_rate)
sys.stderr.write("sample rate: %d\n" %(sample_rate))
DEMOD = cqpsk.cqpsk_demod( samples_per_symbol = sps,
excess_bw=0.35,
costas_alpha=0.03,
gain_mu=0.05,
mu=0.05,
omega_relative_limit=0.05,
log=options.log,
verbose=options.verbose)
OUT = gr.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = gr.fractional_interpolator_cc(0, r)
self.connect(self.f2c, FILTER, INTERPOLATOR, DEMOD, OUT)
def __init__(self,
samplerate,
symbolrate=SYMRATE,
channel_str=None,
sendmsg=True,
debug=False,
samplepersymbol=SPS,
fmdeviation=FM_DEVIATION):
gr.hier_block2.__init__(self, "pocsag",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, 1))
self.samplerate = samplerate
self.symbolrate = symbolrate
self.sendmsg = sendmsg
self.debug = debug
self.samplepersymbol = samplepersymbol
self.fmdeviation = fmdeviation
self.fractional_interpolator = gr.fractional_interpolator_cc(
0, 1.0 * samplerate / (symbolrate * samplepersymbol))
self.quadrature_demod = gr.quadrature_demod_cf(
(symbolrate * samplepersymbol) / (fmdeviation * 4.0))
self.low_pass_filter = gr.fir_filter_fff(
1,
gr.firdes.low_pass(1, symbolrate * samplepersymbol, symbolrate * 2,
symbolrate / 2.0, gr.firdes.WIN_HAMMING, 6.76))
self.digital_clock_recovery_mm = digital.clock_recovery_mm_ff(
samplepersymbol, 0.03 * 0.03 * 0.3, 0.4, 0.03, 1e-4)
self.digital_binary_slicer_fb = digital.binary_slicer_fb()
self.pktdecoder = pocsag_pktdecoder(channel_str=channel_str,
sendmsg=sendmsg,
debug=debug)
self.connect(self, self.fractional_interpolator, self.quadrature_demod,
self.low_pass_filter, self.digital_clock_recovery_mm,
self.digital_binary_slicer_fb, self.pktdecoder, self)
def _set_interpolator(self):
interpolator = gr.fractional_interpolator_cc(0, self.sps)
return interpolator
def __init__(self, options):
gr.top_block.__init__(self)
# Create a UHD source
self._u = uhd.usrp_source(device_addr=options.args,
io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1)
# Set the subdevice spec
if (options.spec):
self._u.set_subdev_spec(options.spec, 0)
# Set the antenna
if (options.antenna):
self._u.set_antenna(options.antenna, 0)
# Pick the lowest possible value for the input rate
supported_rates = self._u.get_samp_rates()
self._u.set_samp_rate(supported_rates.start())
sample_rate = self._u.get_samp_rate()
symbol_rate = 18000
sps = 2
# output rate will be 36,000
ntaps = 11 * sps
new_sample_rate = symbol_rate * sps
# Set receive daughterboard gain
if options.gain is None:
g = self._u.get_gain_range()
options.gain = float(g.stop() + g.start()) / 2
print "Using mid-point gain of", options.gain, "(", g.start(
), "-", g.stop(), ")"
self._u.set_gain(options.gain)
# Set frequency (tune request takes lo_offset)
if (options.lo_offset is not None):
treq = uhd.tune_request(options.freq, options.lo_offset)
else:
treq = uhd.tune_request(options.freq)
tr = self._u.set_center_freq(treq)
if tr == None:
sys.stderr.write('Failed to set center frequency\n')
raise SystemExit, 1
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass,
options.low_pass * 0.1,
gr.firdes.WIN_HANN)
FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps,
options.calibration,
sample_rate)
sys.stderr.write("sample rate: %d\n" % (sample_rate))
DEMOD = cqpsk.cqpsk_demod(samples_per_symbol=sps,
excess_bw=0.35,
costas_alpha=0.03,
gain_mu=0.05,
mu=0.05,
omega_relative_limit=0.05,
log=options.log,
verbose=options.verbose)
OUT = gr.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = gr.fractional_interpolator_cc(0, r)
self.connect(self._u, FILTER, INTERPOLATOR, DEMOD, OUT)
def __init__(self, options):
gr.top_block.__init__(self, "ofdm_tx")
self._tx_freq = options.tx_freq # tranmitter's center frequency
self._tx_subdev_spec = options.tx_subdev_spec # daughterboard to use
self._fusb_block_size = options.fusb_block_size # usb info for USRP
self._fusb_nblocks = options.fusb_nblocks # usb info for USRP
self._which = options.which_usrp
self._bandwidth = options.bandwidth
self.servants = []
self._interface = options.interface
self._mac_addr = options.mac_addr
self._options = copy.copy(options)
self._interpolation = 1
f1 = numpy.array([
-107, 0, 445, 0, -1271, 0, 2959, 0, -6107, 0, 11953, 0, -24706, 0,
82359, 262144 / 2, 82359, 0, -24706, 0, 11953, 0, -6107, 0, 2959,
0, -1271, 0, 445, 0, -107
], numpy.float64) / 262144.
print "Software interpolation: %d" % (self._interpolation)
bw = 0.5 / self._interpolation
tb = bw / 5
if self._interpolation > 1:
self.filter = gr.hier_block2(
"filter", gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_gr_complex))
self.filter.connect(self.filter, gr.interp_fir_filter_ccf(2, f1),
gr.interp_fir_filter_ccf(2, f1), self.filter)
print "New"
#
#
# self.filt_coeff = optfir.low_pass(1.0, 1.0, bw, bw+tb, 0.2, 60.0, 0)
# self.filter = gr.interp_fir_filter_ccf(self._interpolation,self.filt_coeff)
# print "Software interpolation filter length: %d" % (len(self.filt_coeff))
else:
self.filter = None
if not options.from_file is None:
# sent captured file to usrp
self.src = gr.file_source(gr.sizeof_gr_complex, options.from_file)
self._setup_usrp_sink()
if hasattr(self, "filter"):
self.connect(self.src, self.filter, self.u) #,self.filter
else:
self.connect(self.src, self.u)
return
self._setup_tx_path(options)
config = station_configuration()
self.enable_info_tx("info_tx", "pa_user")
# if not options.no_cheat:
# self.txpath.enable_channel_cheating("channelcheat")
self.txpath.enable_txpower_adjust("txpower")
self.txpath.publish_txpower("txpower_info")
#self.enable_txfreq_adjust("txfreq")
if options.nullsink:
self.dst = gr.null_sink(gr.sizeof_gr_complex)
self.dst_2 = gr.null_sink(gr.sizeof_gr_complex)
else:
if not options.to_file is None:
# capture transmitter's stream to disk
self.dst = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
self.dst_2 = gr.file_sink(gr.sizeof_gr_complex,
options.to_file)
tmp = gr.throttle(gr.sizeof_gr_complex, 1e5)
tmp_2 = gr.throttle(gr.sizeof_gr_complex, 1e5)
self.connect(tmp, self.dst)
self.connect(tmp_2, self.dst_2)
self.dst = tmp
self.dst_2 = tmp_2
if options.force_filter:
print "Forcing filter usage"
self.connect(self.filter, self.dst)
self.dst = self.filter
else:
# connect transmitter to usrp
self._setup_usrp_sink()
if options.dyn_freq:
self.enable_txfreq_adjust("txfreq")
if self.filter is not None:
self.connect(self.filter, self.dst)
self.dst = self.filter
if options.record:
log_to_file(self, self.txpath, "data/txpath_out.compl")
#self.publish_spectrum( 256 )
if options.measure:
self.m = throughput_measure(gr.sizeof_gr_complex)
self.connect(self.m, self.dst)
self.dst = self.m
if options.samplingoffset is not None:
soff = options.samplingoffset
interp = gr.fractional_interpolator_cc(0.0, soff)
self.connect(interp, self.dst)
self.dst = interp
if options.snr is not None:
# if options.berm is not None:
# noise_sigma = 380 #empirically given, gives the received SNR range of (1:28) for tx amp. range of (500:10000) which is set in rm_ber_measurement.py
# #check for fading channel
# else:
snr_db = options.snr
snr = 10.0**(snr_db / 10.0)
noise_sigma = sqrt(config.rms_amplitude**2 / snr)
print " Noise St. Dev. %d" % (noise_sigma)
awgn_chan = gr.add_cc()
awgn_noise_src = ofdm.complex_white_noise(0.0, noise_sigma)
self.connect(awgn_noise_src, (awgn_chan, 1))
self.connect(awgn_chan, self.dst)
self.dst = awgn_chan
if options.berm is False:
fad_chan = itpp.tdl_channel() #[0, -7, -20], [0, 2, 6]
#fad_chan.set_norm_doppler( 1e-9 )
#fad_chan.set_LOS( [500.,0,0] )
fad_chan.set_channel_profile(itpp.ITU_Pedestrian_A, 5e-8)
fad_chan.set_norm_doppler(1e-8)
# fad_chan = gr.fir_filter_ccc(1,[1.0,0.0,2e-1+0.1j,1e-4-0.04j])
self.connect(fad_chan, self.dst)
self.dst = fad_chan
if options.freqoff is not None:
freq_shift = gr.multiply_cc()
norm_freq = options.freqoff / config.fft_length
freq_off_src = gr.sig_source_c(1.0, gr.GR_SIN_WAVE, norm_freq, 1.0,
0.0)
self.connect(freq_off_src, (freq_shift, 1))
dst = self.dst
self.connect(freq_shift, dst)
self.dst = freq_shift
self.connect((self.txpath, 0), self.dst)
self.connect((self.txpath, 1), self.dst_2)
if options.cheat:
self.txpath.enable_channel_cheating("channelcheat")
print "Hit Strg^C to terminate"
def __init__(self, dab_params, rx_params, verbose=False, debug=False): """ Hierarchical block for OFDM demodulation @param dab_params DAB parameter object (dab.parameters.dab_parameters) @param rx_params RX parameter object (dab.parameters.receiver_parameters) @param debug enables debug output to files @param verbose whether to produce verbose messages """ self.dp = dp = dab_params self.rp = rp = rx_params self.verbose = verbose if self.rp.softbits: gr.hier_block2.__init__(self,"ofdm_demod", gr.io_signature (1, 1, gr.sizeof_gr_complex), # input signature gr.io_signature2(2, 2, gr.sizeof_float*self.dp.num_carriers*2, gr.sizeof_char)) # output signature else: gr.hier_block2.__init__(self,"ofdm_demod", gr.io_signature (1, 1, gr.sizeof_gr_complex), # input signature gr.io_signature2(2, 2, gr.sizeof_char*self.dp.num_carriers/4, gr.sizeof_char)) # output signature # workaround for a problem that prevents connecting more than one block directly (see trac ticket #161) #self.input = gr.kludge_copy(gr.sizeof_gr_complex) self.input = blocks.multiply_const_cc(1.0) # FIXME self.connect(self, self.input) # input filtering if self.rp.input_fft_filter: if verbose: print "--> RX filter enabled" lowpass_taps = filter.firdes_low_pass(1.0, # gain dp.sample_rate, # sampling rate rp.filt_bw, # cutoff frequency rp.filt_tb, # width of transition band filter.firdes.WIN_HAMMING) # Hamming window self.fft_filter = filter.fft_filter_ccc(1, lowpass_taps) # correct sample rate offset, if enabled if self.rp.autocorrect_sample_rate: if verbose: print "--> dynamic sample rate correction enabled" self.rate_detect_ns = dab.detect_null(dp.ns_length, False) self.rate_estimator = dab.estimate_sample_rate_bf(dp.sample_rate, dp.frame_length) self.rate_prober = blocks.probe_signal_f() self.connect(self.input, self.rate_detect_ns, self.rate_estimator, self.rate_prober) # self.resample = gr.fractional_interpolator_cc(0, 1) self.resample = dab.fractional_interpolator_triggered_update_cc(0,1) self.connect(self.rate_detect_ns, (self.resample,1)) self.updater = Timer(0.1,self.update_correction) # self.updater = threading.Thread(target=self.update_correction) self.run_interpolater_update_thread = True self.updater.setDaemon(True) self.updater.start() else: self.run_interpolater_update_thread = False if self.rp.sample_rate_correction_factor != 1: if verbose: print "--> static sample rate correction enabled" self.resample = gr.fractional_interpolator_cc(0, self.rp.sample_rate_correction_factor) # timing and fine frequency synchronisation self.sync = dab.ofdm_sync_dab2(self.dp, self.rp, debug) # ofdm symbol sampler self.sampler = dab.ofdm_sampler(dp.fft_length, dp.cp_length, dp.symbols_per_frame, rp.cp_gap) # fft for symbol vectors self.fft = fft.fft_vcc(dp.fft_length, True, [], True) # coarse frequency synchronisation self.cfs = dab.ofdm_coarse_frequency_correct(dp.fft_length, dp.num_carriers, dp.cp_length) # diff phasor self.phase_diff = dab.diff_phasor_vcc(dp.num_carriers) # remove pilot symbol self.remove_pilot = dab.ofdm_remove_first_symbol_vcc(dp.num_carriers) # magnitude equalisation if self.rp.equalize_magnitude: if verbose: print "--> magnitude equalization enabled" self.equalizer = dab.magnitude_equalizer_vcc(dp.num_carriers, rp.symbols_for_magnitude_equalization) # frequency deinterleaving self.deinterleave = dab.frequency_interleaver_vcc(dp.frequency_deinterleaving_sequence_array) # symbol demapping self.demapper = dab.qpsk_demapper_vcb(dp.num_carriers) # # connect everything # if self.rp.autocorrect_sample_rate or self.rp.sample_rate_correction_factor != 1: self.connect(self.input, self.resample) self.input2 = self.resample else: self.input2 = self.input if self.rp.input_fft_filter: self.connect(self.input2, self.fft_filter, self.sync) else: self.connect(self.input2, self.sync) # data stream self.connect((self.sync, 0), (self.sampler, 0), self.fft, (self.cfs, 0), self.phase_diff, (self.remove_pilot,0)) if self.rp.equalize_magnitude: self.connect((self.remove_pilot,0), (self.equalizer,0), self.deinterleave) else: self.connect((self.remove_pilot,0), self.deinterleave) if self.rp.softbits: if verbose: print "--> using soft bits" self.softbit_interleaver = dab.complex_to_interleaved_float_vcf(self.dp.num_carriers) self.connect(self.deinterleave, self.softbit_interleaver, (self,0)) else: self.connect(self.deinterleave, self.demapper, (self,0)) # control stream self.connect((self.sync, 1), (self.sampler, 1), (self.cfs, 1), (self.remove_pilot,1)) if self.rp.equalize_magnitude: self.connect((self.remove_pilot,1), (self.equalizer,1), (self,1)) else: self.connect((self.remove_pilot,1), (self,1)) # calculate an estimate of the SNR self.phase_var_decim = blocks.keep_one_in_n(gr.sizeof_gr_complex*self.dp.num_carriers, self.rp.phase_var_estimate_downsample) self.phase_var_arg = blocks.complex_to_arg(dp.num_carriers) self.phase_var_v2s = blocks.vector_to_stream(gr.sizeof_float, dp.num_carriers) self.phase_var_mod = dab.modulo_ff(pi/2) self.phase_var_avg_mod = filter.iir_filter_ffd([rp.phase_var_estimate_alpha], [0,1-rp.phase_var_estimate_alpha]) self.phase_var_sub_avg = blocks.sub_ff() self.phase_var_sqr = blocks.multiply_ff() self.phase_var_avg = filter.iir_filter_ffd([rp.phase_var_estimate_alpha], [0,1-rp.phase_var_estimate_alpha]) self.probe_phase_var = blocks.probe_signal_f() self.connect((self.remove_pilot,0), self.phase_var_decim, self.phase_var_arg, self.phase_var_v2s, self.phase_var_mod, (self.phase_var_sub_avg,0), (self.phase_var_sqr,0)) self.connect(self.phase_var_mod, self.phase_var_avg_mod, (self.phase_var_sub_avg,1)) self.connect(self.phase_var_sub_avg, (self.phase_var_sqr,1)) self.connect(self.phase_var_sqr, self.phase_var_avg, self.probe_phase_var) # measure processing rate self.measure_rate = dab.measure_processing_rate(gr.sizeof_gr_complex, 2000000) self.connect(self.input, self.measure_rate) # debugging if debug: self.connect(self.fft, blocks.file_sink(gr.sizeof_gr_complex*dp.fft_length, "debug/ofdm_after_fft.dat")) self.connect((self.cfs,0), blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/ofdm_after_cfs.dat")) self.connect(self.phase_diff, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/ofdm_diff_phasor.dat")) self.connect((self.remove_pilot,0), blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/ofdm_pilot_removed.dat")) self.connect((self.remove_pilot,1), blocks.file_sink(gr.sizeof_char, "debug/ofdm_after_cfs_trigger.dat")) self.connect(self.deinterleave, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/ofdm_deinterleaved.dat")) if self.rp.equalize_magnitude: self.connect(self.equalizer, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/ofdm_equalizer.dat")) if self.rp.softbits: self.connect(self.softbit_interleaver, blocks.file_sink(gr.sizeof_float*dp.num_carriers*2, "debug/softbits.dat"))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
options = get_options()
self.tune_corrector_callback = tune_corrector(self)
self.synchronizer_callback = synchronizer(self)
self.converter = gr.vector_to_stream(gr.sizeof_float, 142)
self.ifreq = options.frequency
self.rfgain = options.gain
self.src = osmosdr.source_c(options.args)
self.src.set_center_freq(self.ifreq)
self.src.set_sample_rate(int(options.sample_rate))
if self.rfgain is None:
self.src.set_gain_mode(1)
self.iagc = 1
self.rfgain = 0
else:
self.iagc = 0
self.src.set_gain_mode(0)
self.src.set_gain(self.rfgain)
# may differ from the requested rate
sample_rate = self.src.get_sample_rate()
sys.stderr.write("sample rate: %d\n" % (sample_rate))
gsm_symb_rate = 1625000.0 / 6.0
sps = sample_rate / gsm_symb_rate / 4
out_sample_rate = gsm_symb_rate * 4
self.offset = 0
taps = gr.firdes.low_pass(1.0, sample_rate, 145e3, 10e3, gr.firdes.WIN_HANN)
self.tuner = gr.freq_xlating_fir_filter_ccf(1, taps, self.offset, sample_rate)
self.interpolator = gr.fractional_interpolator_cc(0, sps)
self.receiver = gsm.receiver_cf(
self.tune_corrector_callback, self.synchronizer_callback, 4,
options.key.replace(' ', '').lower(),
options.configuration.upper())
self.output = gr.file_sink(gr.sizeof_float, options.output_file)
self.connect(self.src, self.tuner, self.interpolator, self.receiver, self.converter, self.output)
def set_ifreq(ifreq):
self.ifreq = ifreq
self._ifreq_text_box.set_value(self.ifreq)
self.src.set_center_freq(self.ifreq)
self._ifreq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.ifreq,
callback=set_ifreq,
label="Center Frequency",
converter=forms.float_converter(),
)
self.Add(self._ifreq_text_box)
def set_iagc(iagc):
self.iagc = iagc
self._agc_check_box.set_value(self.iagc)
self.src.set_gain_mode(self.iagc, 0)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
self._agc_check_box = forms.check_box(
parent=self.GetWin(),
value=self.iagc,
callback=set_iagc,
label="Automatic Gain",
true=1,
false=0,
)
self.Add(self._agc_check_box)
def set_rfgain(rfgain):
self.rfgain = rfgain
self._rfgain_slider.set_value(self.rfgain)
self._rfgain_text_box.set_value(self.rfgain)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
_rfgain_sizer = wx.BoxSizer(wx.VERTICAL)
self._rfgain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
label="RF Gain",
converter=forms.float_converter(),
proportion=0,
)
self._rfgain_slider = forms.slider(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
minimum=0,
maximum=50,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_rfgain_sizer)
def fftsink2_callback(x, y):
if abs(x / (sample_rate / 2)) > 0.9:
set_ifreq(self.ifreq + x / 2)
else:
sys.stderr.write("coarse tuned to: %d Hz\n" % x)
self.offset = -x
self.tuner.set_center_freq(self.offset)
self.scope = fftsink2.fft_sink_c(self.GetWin(),
title="Wideband Spectrum (click to coarse tune)",
fft_size=1024,
sample_rate=sample_rate,
ref_scale=2.0,
ref_level=0,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.3)
self.Add(self.scope.win)
self.scope.set_callback(fftsink2_callback)
self.connect(self.src, self.scope)
def fftsink2_callback2(x, y):
self.offset = self.offset - (x / 10)
sys.stderr.write("fine tuned to: %d Hz\n" % self.offset)
self.tuner.set_center_freq(self.offset)
self.scope2 = fftsink2.fft_sink_c(self.GetWin(),
title="Channel Spectrum (click to fine tune)",
fft_size=1024,
sample_rate=gsm_symb_rate * 4,
ref_scale=2.0,
ref_level=-20,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.3)
self.Add(self.scope2.win)
self.scope2.set_callback(fftsink2_callback2)
self.connect(self.interpolator, self.scope2)
def __init__(self):
#grc_wxgui.top_block_gui.__init__(self, title="Top Block")
gr.top_block.__init__(self)
print "abc"
##################################################
# Variables
##################################################
#self.samp_rate = samp_rate = 32000
self.osr = 4
self.key = ''
self.configuration = ''
self.clock_rate = 52e6
self.input_rate = self.clock_rate / 72 #TODO: what about usrp value?
self.gsm_symb_rate = 1625000.0 / 6.0
self.sps = self.input_rate / self.gsm_symb_rate
# configure channel filter
filter_cutoff = 135e3 #135,417Hz is GSM bandwidth
filter_t_width = 10e3
offset = 0.0
##################################################
# Blocks
##################################################
self.gr_null_sink_0 = gr.null_sink(gr.sizeof_gr_complex * 1)
print "Input files: ", downfile, " ", upfile
self.gr_file_source_0 = gr.file_source(gr.sizeof_gr_complex * 1,
downfile, False)
self.gr_file_source_1 = gr.file_source(gr.sizeof_gr_complex * 1,
upfile, False)
filter_taps = gr.firdes.low_pass(1.0, self.input_rate, filter_cutoff,
filter_t_width, gr.firdes.WIN_HAMMING)
print len(filter_taps)
self.filter0 = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset,
self.input_rate)
self.filter1 = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset,
self.input_rate)
self.interpolator_1 = gr.fractional_interpolator_cc(0, self.sps)
self.tuner_callback = tuner(self)
self.synchronizer_callback = synchronizer(self)
#self.buffer = howto.buffer_cc()
self.burst_cb = burst_callback(self)
print ">>>>>Input rate: ", self.input_rate
#self.burst = gsm.burst_cf(self.burst_cb,self.input_rate)
self.receiver = gsm.receiver_cf(self.tuner_callback,
self.synchronizer_callback, self.osr,
self.key.replace(' ', '').lower(),
self.configuration.upper())
##################################################
# Connections
##################################################
#self.connect((self.gr_file_source_0, 0), (self.filter0, 0), (self.burst, 0))
self.connect((self.gr_file_source_1, 0), (self.filter1, 0),
(self.interpolator_1, 0), (self.receiver, 0))
# may differ from the requested rate
sample_rate = self.src.get_sample_rate()
sys.stderr.write("sample rate: %d\n" % (sample_rate))
gsm_symb_rate = 1625000.0 / 6.0
sps = sample_rate / gsm_symb_rate / 4
out_sample_rate = gsm_symb_rate * 4
self.offset = 0
taps = gr.firdes.low_pass(1.0, sample_rate, 145e3, 10e3, gr.firdes.WIN_HANN)
self.tuner = gr.freq_xlating_fir_filter_ccf(1, taps, self.offset, sample_rate)
self.interpolator = gr.fractional_interpolator_cc(0, sps)
#options.configuration = "2S"
self.receiver = gsm.receiver_cf(
self.tune_corrector_callback, self.synchronizer_callback, 4,
options.key.replace(' ', '').lower(),
options.configuration.upper())
self.output = gr.file_sink(gr.sizeof_float, options.output_file)
self.connect(self.src, self.tuner, self.interpolator,self.receiver, self.converter, self.output)
def set_ifreq(ifreq):
self.ifreq = ifreq
self._ifreq_text_box.set_value(self.ifreq)
self.src.set_center_freq(self.ifreq)
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
options = get_options()
self.tune_corrector_callback = tune_corrector(self)
self.synchronizer_callback = synchronizer(self)
self.converter = gr.vector_to_stream(gr.sizeof_float, 142)
self.ifreq = options.frequency
self.rfgain = options.gain
self.src = osmosdr.source_c(options.args)
# added by scateu @ 2014-1-9
self.src.set_freq_corr(0, 0)
self.src.set_dc_offset_mode(1, 0)
self.src.set_iq_balance_mode(0, 0)
self.src.set_gain_mode(0, 0)
self.src.set_gain(14, 0)
self.src.set_if_gain(58, 0)
self.src.set_bb_gain(20, 0)
self.src.set_antenna("", 0)
self.src.set_bandwidth(0, 0)
self.src.set_center_freq(self.ifreq)
self.src.set_sample_rate(int(options.sample_rate))
if self.rfgain is None:
self.src.set_gain_mode(1)
self.iagc = 1
self.rfgain = 0
else:
self.iagc = 0
self.src.set_gain_mode(0)
self.src.set_gain(self.rfgain)
# may differ from the requested rate
sample_rate = self.src.get_sample_rate()
sys.stderr.write("sample rate: %d\n" % (sample_rate))
gsm_symb_rate = 1625000.0 / 6.0
sps = sample_rate / gsm_symb_rate / 4
out_sample_rate = gsm_symb_rate * 4
self.offset = 0
taps = gr.firdes.low_pass(1.0, sample_rate, 145e3, 10e3,
gr.firdes.WIN_HANN)
self.tuner = gr.freq_xlating_fir_filter_ccf(1, taps, self.offset,
sample_rate)
self.interpolator = gr.fractional_interpolator_cc(0, sps)
self.receiver = gsm.receiver_cf(self.tune_corrector_callback,
self.synchronizer_callback, 4,
options.key.replace(' ', '').lower(),
options.configuration.upper())
self.output = gr.file_sink(gr.sizeof_float, options.output_file)
self.connect(self.src, self.tuner, self.interpolator, self.receiver,
self.converter, self.output)
def set_ifreq(ifreq):
self.ifreq = ifreq
self._ifreq_text_box.set_value(self.ifreq)
self.src.set_center_freq(self.ifreq)
self._ifreq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.ifreq,
callback=set_ifreq,
label="Center Frequency",
converter=forms.float_converter(),
)
self.Add(self._ifreq_text_box)
def set_iagc(iagc):
self.iagc = iagc
self._agc_check_box.set_value(self.iagc)
self.src.set_gain_mode(self.iagc, 0)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
self._agc_check_box = forms.check_box(
parent=self.GetWin(),
value=self.iagc,
callback=set_iagc,
label="Automatic Gain",
true=1,
false=0,
)
self.Add(self._agc_check_box)
def set_rfgain(rfgain):
self.rfgain = rfgain
self._rfgain_slider.set_value(self.rfgain)
self._rfgain_text_box.set_value(self.rfgain)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
_rfgain_sizer = wx.BoxSizer(wx.VERTICAL)
self._rfgain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
label="RF Gain",
converter=forms.float_converter(),
proportion=0,
)
self._rfgain_slider = forms.slider(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
minimum=0,
maximum=50,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_rfgain_sizer)
def fftsink2_callback(x, y):
if abs(x / (sample_rate / 2)) > 0.9:
set_ifreq(self.ifreq + x / 2)
else:
sys.stderr.write("coarse tuned to: %d Hz\n" % x)
self.offset = -x
self.tuner.set_center_freq(self.offset)
self.scope = fftsink2.fft_sink_c(
self.GetWin(),
title="Wideband Spectrum (click to coarse tune)",
fft_size=1024,
sample_rate=sample_rate,
ref_scale=2.0,
ref_level=0,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.3)
self.Add(self.scope.win)
self.scope.set_callback(fftsink2_callback)
self.connect(self.src, self.scope)
def fftsink2_callback2(x, y):
self.offset = self.offset - (x / 10)
sys.stderr.write("fine tuned to: %d Hz\n" % self.offset)
self.tuner.set_center_freq(self.offset)
self.scope2 = fftsink2.fft_sink_c(
self.GetWin(),
title="Channel Spectrum (click to fine tune)",
fft_size=1024,
sample_rate=gsm_symb_rate * 4,
ref_scale=2.0,
ref_level=-20,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.3)
self.Add(self.scope2.win)
self.scope2.set_callback(fftsink2_callback2)
self.connect(self.interpolator, self.scope2)
def __init__ (self, options):
gr.top_block.__init__(self, "ofdm_tx")
self._tx_freq = options.tx_freq # tranmitter's center frequency
self._tx_subdev_spec = options.tx_subdev_spec # daughterboard to use
self._fusb_block_size = options.fusb_block_size # usb info for USRP
self._fusb_nblocks = options.fusb_nblocks # usb info for USRP
self._which = options.which_usrp
self._bandwidth = options.bandwidth
self.servants = []
self._interface = options.interface
self._mac_addr = options.mac_addr
self._options = copy.copy( options )
self._interpolation = 1
f1 = numpy.array([-107,0,445,0,-1271,0,2959,0,-6107,0,11953,
0,-24706,0,82359,262144/2,82359,0,-24706,0,
11953,0,-6107,0,2959,0,-1271,0,445,0,-107],
numpy.float64)/262144.
print "Software interpolation: %d" % (self._interpolation)
bw = 0.5/self._interpolation
tb = bw/5
if self._interpolation > 1:
self.filter = gr.hier_block2("filter",
gr.io_signature(1,1,gr.sizeof_gr_complex),
gr.io_signature(1,1,gr.sizeof_gr_complex))
self.filter.connect( self.filter, gr.interp_fir_filter_ccf(2,f1),
gr.interp_fir_filter_ccf(2,f1), self.filter )
print "New"
#
#
# self.filt_coeff = optfir.low_pass(1.0, 1.0, bw, bw+tb, 0.2, 60.0, 0)
# self.filter = gr.interp_fir_filter_ccf(self._interpolation,self.filt_coeff)
# print "Software interpolation filter length: %d" % (len(self.filt_coeff))
else:
self.filter = None
if not options.from_file is None:
# sent captured file to usrp
self.src = gr.file_source(gr.sizeof_gr_complex,options.from_file)
self._setup_usrp_sink()
if hasattr(self, "filter"):
self.connect(self.src,self.filter,self.u) #,self.filter
else:
self.connect(self.src,self.u)
return
self._setup_tx_path(options)
config = station_configuration()
self.enable_info_tx("info_tx", "pa_user")
# if not options.no_cheat:
# self.txpath.enable_channel_cheating("channelcheat")
self.txpath.enable_txpower_adjust("txpower")
self.txpath.publish_txpower("txpower_info")
#self.enable_txfreq_adjust("txfreq")
if options.nullsink:
self.dst = gr.null_sink( gr.sizeof_gr_complex )
else:
if not options.to_file is None:
# capture transmitter's stream to disk
self.dst = gr.file_sink(gr.sizeof_gr_complex,options.to_file)
tmp = gr.throttle(gr.sizeof_gr_complex,1e5)
self.connect( tmp, self.dst )
self.dst = tmp
if options.force_filter:
print "Forcing filter usage"
self.connect( self.filter, self.dst )
self.dst = self.filter
else:
# connect transmitter to usrp
self._setup_usrp_sink()
if options.dyn_freq:
self.enable_txfreq_adjust("txfreq")
if self.filter is not None:
self.connect( self.filter,self.dst )
self.dst = self.filter
if options.record:
log_to_file( self, self.txpath, "data/txpath_out.compl" )
#self.publish_spectrum( 256 )
if options.measure:
self.m = throughput_measure(gr.sizeof_gr_complex)
self.connect( self.m, self.dst )
self.dst = self.m
if options.samplingoffset is not None:
soff = options.samplingoffset
interp = gr.fractional_interpolator_cc(0.0,soff)
self.connect( interp, self.dst )
self.dst = interp
if options.snr is not None:
# if options.berm is not None:
# noise_sigma = 380 #empirically given, gives the received SNR range of (1:28) for tx amp. range of (500:10000) which is set in rm_ber_measurement.py
# #check for fading channel
# else:
snr_db = options.snr
snr = 10.0**(snr_db/10.0)
noise_sigma = sqrt( config.rms_amplitude**2 / snr )
print " Noise St. Dev. %d" % (noise_sigma)
awgn_chan = gr.add_cc()
awgn_noise_src = ofdm.complex_white_noise( 0.0, noise_sigma )
self.connect( awgn_noise_src, (awgn_chan,1) )
self.connect( awgn_chan, self.dst )
self.dst = awgn_chan
if options.berm is False:
fad_chan = itpp.tdl_channel( ) #[0, -7, -20], [0, 2, 6]
#fad_chan.set_norm_doppler( 1e-9 )
#fad_chan.set_LOS( [500.,0,0] )
fad_chan.set_channel_profile( itpp.ITU_Pedestrian_A, 5e-8 )
fad_chan.set_norm_doppler( 1e-8 )
# fad_chan = gr.fir_filter_ccc(1,[1.0,0.0,2e-1+0.1j,1e-4-0.04j])
self.connect( fad_chan, self.dst )
self.dst = fad_chan
if options.freqoff is not None:
freq_shift = gr.multiply_cc()
norm_freq = options.freqoff / config.fft_length
freq_off_src = gr.sig_source_c(1.0, gr.GR_SIN_WAVE, norm_freq, 1.0, 0.0 )
self.connect( freq_off_src, ( freq_shift, 1 ) )
dst = self.dst
self.connect( freq_shift, dst )
self.dst = freq_shift
self.connect( self.txpath, self.dst )
if options.cheat:
self.txpath.enable_channel_cheating("channelcheat")
print "Hit Strg^C to terminate"
def __init__(self):
#grc_wxgui.top_block_gui.__init__(self, title="Top Block")
gr.top_block.__init__(self)
##################################################
# Variables
##################################################
#self.samp_rate = samp_rate = 32000
self.osr = 4
self.key = 'AD 6A 3E C2 B4 42 E4 00'
self.configuration = ch
self.ch0 = ch_0
self.ch1 = ch_1
self.clock_rate = 52e6
self.input_rate = self.clock_rate / 72 #TODO: what about usrp value?
self.gsm_symb_rate = 1625000.0 / 6.0
self.sps = self.input_rate / self.gsm_symb_rate / self.osr
# configure channel filter
filter_cutoff = 145e3 #135,417Hz is GSM bandwidth
filter_t_width = 10e3
offset = 0.0
##################################################
# Blocks
##################################################
self.gr_null_sink_0 = gr.null_sink(gr.sizeof_gr_complex * 1)
print "Input files: ", file_0, " ", file_1
self.gr_file_source_0 = gr.file_source(gr.sizeof_gr_complex * 1,
file_0, False)
self.gr_file_source_1 = gr.file_source(gr.sizeof_gr_complex * 1,
file_1, False)
filter_taps = gr.firdes.low_pass(1.0, self.input_rate, filter_cutoff,
filter_t_width, gr.firdes.WIN_HAMMING)
self.filter_0 = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset,
self.input_rate)
self.filter_1 = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset,
self.input_rate)
self.interpolator_0 = gr.fractional_interpolator_cc(0, self.sps)
self.interpolator_1 = gr.fractional_interpolator_cc(0, self.sps)
self.tuner_callback = tuner(self)
self.synchronizer_callback = synchronizer(self)
#print ">>>>>Input rate: ", self.input_rate
self.receiver = gsm.receiver_cf(self.tuner_callback,
self.synchronizer_callback, self.osr,
self.key.replace(' ', '').lower(),
self.configuration.upper(), self.ch0,
self.ch1, "127.0.0.1", 8080)
# self.receiver = gsm.receiver_cf(self.tuner_callback, self.synchronizer_callback, self.osr, self.key.replace(' ', '').lower(), self.configuration.upper(), self.ch0, self.ch1)
##################################################
# Connections
##################################################
self.connect((self.gr_file_source_1, 0), (self.filter_1, 0),
(self.interpolator_1, 0), (self.receiver, 1))
# self.connect((self.gr_file_source_1, 0), (self.filter_1, 0), (self.interpolator_1, 0), (self.receiver, 1))
self.connect((self.gr_file_source_0, 0), (self.filter_0, 0),
(self.interpolator_0, 0), (self.receiver, 0))
def __init__(self, options):
gr.top_block.__init__(self)
fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
self._u = usrp.source_c(decim_rate=options.decim, fusb_block_size=fusb_block_size, fusb_nblocks=fusb_nblocks)
# master clock
if options.fpga_freq is not None:
self._u.set_fpga_master_clock_freq(long(options.fpga_freq))
# default subdev if use didn't pick one
if options.rx_subdev_spec is None:
if u.db(0, 0).dbid() >= 0:
options.rx_subdev_spec = (0, 0)
elif u.db(1, 0).dbid() >= 0:
options.rx_subdev_spec = (1, 0)
else:
options.rx_subdev_spec = (0, 0)
# configure usrp mux
self._u.set_mux(usrp.determine_rx_mux_value(self._u, options.rx_subdev_spec))
# determine the daughterboard subdevice
self.subdev = usrp.selected_subdev(self._u, options.rx_subdev_spec)
# select antenna
if options.antenna is not None:
print "Selecting antenna %s" % (options.antenna,)
self.subdev.select_rx_antenna(options.antenna)
# set initial values
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
options.gain = float(g[0]+g[1])/2
r = self._u.tune(0, self.subdev, options.freq)
self.subdev.set_gain(options.gain)
#sample_rate = options.fpga_clock/options.decim
sample_rate = self._u.adc_freq() / self._u.decim_rate()
symbol_rate = 18000
sps = 2
# output rate will be 36,000
ntaps = 11 * sps
new_sample_rate = symbol_rate * sps
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, gr.firdes.WIN_HANN)
FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps, options.calibration, sample_rate)
sys.stderr.write("sample rate: %d\n" %(sample_rate))
DEMOD = cqpsk.cqpsk_demod( samples_per_symbol = sps,
excess_bw=0.35,
costas_alpha=0.03,
gain_mu=0.05,
mu=0.05,
omega_relative_limit=0.05,
log=options.log,
verbose=options.verbose)
OUT = gr.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = gr.fractional_interpolator_cc(0, r)
self.connect(self._u, FILTER, INTERPOLATOR, DEMOD, OUT)
def test_000_make(self):
op = gr.fractional_interpolator_ff(0.0, 1.0)
op2 = gr.fractional_interpolator_cc(0.0, 1.0)
def __init__(self, options):
gr.top_block.__init__(self)
# Create a UHD source
self._u = uhd.usrp_source(
device_addr=options.args,
io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1)
# Set the subdevice spec
if(options.spec):
self._u.set_subdev_spec(options.spec, 0)
# Set the antenna
if(options.antenna):
self._u.set_antenna(options.antenna, 0)
# Pick the lowest possible value for the input rate
supported_rates = self._u.get_samp_rates()
self._u.set_samp_rate(supported_rates.start())
sample_rate = self._u.get_samp_rate()
symbol_rate = 18000
sps = 2
# output rate will be 36,000
ntaps = 11 * sps
new_sample_rate = symbol_rate * sps
# Set receive daughterboard gain
if options.gain is None:
g = self._u.get_gain_range()
options.gain = float(g.stop()+g.start())/2
print "Using mid-point gain of", options.gain, "(", g.start(), "-", g.stop(), ")"
self._u.set_gain(options.gain)
# Set frequency (tune request takes lo_offset)
if(options.lo_offset is not None):
treq = uhd.tune_request(options.freq, options.lo_offset)
else:
treq = uhd.tune_request(options.freq)
tr = self._u.set_center_freq(treq)
if tr == None:
sys.stderr.write('Failed to set center frequency\n')
raise SystemExit, 1
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, gr.firdes.WIN_HANN)
FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps, options.calibration, sample_rate)
sys.stderr.write("sample rate: %d\n" %(sample_rate))
DEMOD = cqpsk.cqpsk_demod( samples_per_symbol = sps,
excess_bw=0.35,
costas_alpha=0.03,
gain_mu=0.05,
mu=0.05,
omega_relative_limit=0.05,
log=options.log,
verbose=options.verbose)
OUT = gr.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = gr.fractional_interpolator_cc(0, r)
self.connect(self._u, FILTER, INTERPOLATOR, DEMOD, OUT)
def _set_interpolator(self):
interpolator = gr.fractional_interpolator_cc(0, self.sps)
return interpolator
def __init__(self):
#grc_wxgui.top_block_gui.__init__(self, title="Top Block")
gr.top_block.__init__(self)
##################################################
# Variables
##################################################
#self.samp_rate = samp_rate = 32000
self.osr = 4
self.key = 'AD 6A 3E C2 B4 42 E4 00'
self.configuration = ch
self.ch0 = ch_0
self.ch1 = ch_1
self.clock_rate = 52e6
self.input_rate = self.clock_rate / 72 #TODO: what about usrp value?
self.gsm_symb_rate = 1625000.0 / 6.0
self.sps = self.input_rate / self.gsm_symb_rate / self.osr
# configure channel filter
filter_cutoff = 145e3 #135,417Hz is GSM bandwidth
filter_t_width = 10e3
offset = 0.0
##################################################
# Blocks
##################################################
self.gr_null_sink_0 = gr.null_sink(gr.sizeof_gr_complex*1)
print "Input files: ", file_0, " ", file_1
self.gr_file_source_0 = gr.file_source(gr.sizeof_gr_complex*1, file_0, False)
self.gr_file_source_1 = gr.file_source(gr.sizeof_gr_complex*1, file_1, False)
filter_taps = gr.firdes.low_pass(1.0, self.input_rate, filter_cutoff, filter_t_width, gr.firdes.WIN_HAMMING)
self.filter_0 = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset, self.input_rate)
self.filter_1 = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset, self.input_rate)
self.interpolator_0 = gr.fractional_interpolator_cc(0, self.sps)
self.interpolator_1 = gr.fractional_interpolator_cc(0, self.sps)
self.tuner_callback = tuner(self)
self.synchronizer_callback = synchronizer(self)
#print ">>>>>Input rate: ", self.input_rate
self.receiver = gsm.receiver_cf(self.tuner_callback, self.synchronizer_callback, self.osr, self.key.replace(' ', '').lower(), self.configuration.upper(), self.ch0, self.ch1, "127.0.0.1", 8080)
# self.receiver = gsm.receiver_cf(self.tuner_callback, self.synchronizer_callback, self.osr, self.key.replace(' ', '').lower(), self.configuration.upper(), self.ch0, self.ch1)
##################################################
# Connections
##################################################
self.connect((self.gr_file_source_1, 0), (self.filter_1, 0), (self.interpolator_1, 0), (self.receiver, 1))
# self.connect((self.gr_file_source_1, 0), (self.filter_1, 0), (self.interpolator_1, 0), (self.receiver, 1))
self.connect((self.gr_file_source_0, 0), (self.filter_0, 0), (self.interpolator_0, 0), (self.receiver, 0))
def __init__(self, dab_params, rx_params, verbose=False, debug=False): """ Hierarchical block for OFDM demodulation @param dab_params DAB parameter object (dab.parameters.dab_parameters) @param rx_params RX parameter object (dab.parameters.receiver_parameters) @param debug enables debug output to files @param verbose whether to produce verbose messages """ self.dp = dp = dab_params self.rp = rp = rx_params self.verbose = verbose if self.rp.softbits: gr.hier_block2.__init__(self,"ofdm_demod", gr.io_signature (1, 1, gr.sizeof_gr_complex), # input signature gr.io_signature2(2, 2, gr.sizeof_float*self.dp.num_carriers*2, gr.sizeof_char)) # output signature else: gr.hier_block2.__init__(self,"ofdm_demod", gr.io_signature (1, 1, gr.sizeof_gr_complex), # input signature gr.io_signature2(2, 2, gr.sizeof_char*self.dp.num_carriers/4, gr.sizeof_char)) # output signature # workaround for a problem that prevents connecting more than one block directly (see trac ticket #161) #self.input = gr.kludge_copy(gr.sizeof_gr_complex) self.input = blocks.multiply_const_cc(1.0) # FIXME self.connect(self, self.input) # input filtering if self.rp.input_fft_filter: if verbose: print "--> RX filter enabled" lowpass_taps = filter.firdes_low_pass(1.0, # gain dp.sample_rate, # sampling rate rp.filt_bw, # cutoff frequency rp.filt_tb, # width of transition band filter.firdes.WIN_HAMMING) # Hamming window self.fft_filter = filter.fft_filter_ccc(1, lowpass_taps) # correct sample rate offset, if enabled if self.rp.autocorrect_sample_rate: if verbose: print "--> dynamic sample rate correction enabled" self.rate_detect_ns = dab.detect_null(dp.ns_length, False) self.rate_estimator = dab.estimate_sample_rate_bf(dp.sample_rate, dp.frame_length) self.rate_prober = blocks.probe_signal_f() self.connect(self.input, self.rate_detect_ns, self.rate_estimator, self.rate_prober) # self.resample = gr.fractional_interpolator_cc(0, 1) self.resample = dab.fractional_interpolator_triggered_update_cc(0,1) self.connect(self.rate_detect_ns, (self.resample,1)) self.updater = Timer(0.1,self.update_correction) # self.updater = threading.Thread(target=self.update_correction) self.run_interpolater_update_thread = True self.updater.setDaemon(True) self.updater.start() else: self.run_interpolater_update_thread = False if self.rp.sample_rate_correction_factor != 1: if verbose: print "--> static sample rate correction enabled" self.resample = gr.fractional_interpolator_cc(0, self.rp.sample_rate_correction_factor) # timing and fine frequency synchronisation self.sync = dab.ofdm_sync_dab2(self.dp, self.rp, debug) # ofdm symbol sampler self.sampler = dab.ofdm_sampler(dp.fft_length, dp.cp_length, dp.symbols_per_frame, rp.cp_gap) # fft for symbol vectors self.fft = fft.fft_vcc(dp.fft_length, True, [], True) # coarse frequency synchronisation self.cfs = dab.ofdm_coarse_frequency_correct(dp.fft_length, dp.num_carriers, dp.cp_length) # diff phasor self.phase_diff = dab.diff_phasor_vcc(dp.num_carriers) # remove pilot symbol self.remove_pilot = dab.ofdm_remove_first_symbol_vcc(dp.num_carriers) # magnitude equalisation if self.rp.equalize_magnitude: if verbose: print "--> magnitude equalization enabled" self.equalizer = dab.magnitude_equalizer_vcc(dp.num_carriers, rp.symbols_for_magnitude_equalization) # frequency deinterleaving self.deinterleave = dab.frequency_interleaver_vcc(dp.frequency_deinterleaving_sequence_array) # symbol demapping self.demapper = dab.qpsk_demapper_vcb(dp.num_carriers) # # connect everything # if self.rp.autocorrect_sample_rate or self.rp.sample_rate_correction_factor != 1: self.connect(self.input, self.resample) self.input2 = self.resample else: self.input2 = self.input if self.rp.input_fft_filter: self.connect(self.input2, self.fft_filter, self.sync) else: self.connect(self.input2, self.sync) # data stream self.connect((self.sync, 0), (self.sampler, 0), self.fft, (self.cfs, 0), self.phase_diff, (self.remove_pilot,0)) if self.rp.equalize_magnitude: self.connect((self.remove_pilot,0), (self.equalizer,0), self.deinterleave) else: self.connect((self.remove_pilot,0), self.deinterleave) if self.rp.softbits: if verbose: print "--> using soft bits" self.softbit_interleaver = dab.complex_to_interleaved_float_vcf(self.dp.num_carriers) self.connect(self.deinterleave, self.softbit_interleaver, (self,0)) else: self.connect(self.deinterleave, self.demapper, (self,0)) # control stream self.connect((self.sync, 1), (self.sampler, 1), (self.cfs, 1), (self.remove_pilot,1)) if self.rp.equalize_magnitude: self.connect((self.remove_pilot,1), (self.equalizer,1), (self,1)) else: self.connect((self.remove_pilot,1), (self,1)) # calculate an estimate of the SNR self.phase_var_decim = blocks.keep_one_in_n(gr.sizeof_gr_complex*self.dp.num_carriers, self.rp.phase_var_estimate_downsample) self.phase_var_arg = blocks.complex_to_arg(dp.num_carriers) self.phase_var_v2s = blocks.vector_to_stream(gr.sizeof_float, dp.num_carriers) self.phase_var_mod = dab.modulo_ff(pi/2) self.phase_var_avg_mod = filter.iir_filter_ffd([rp.phase_var_estimate_alpha], [0,1-rp.phase_var_estimate_alpha]) self.phase_var_sub_avg = blocks.sub_ff() self.phase_var_sqr = blocks.multiply_ff() self.phase_var_avg = filter.iir_filter_ffd([rp.phase_var_estimate_alpha], [0,1-rp.phase_var_estimate_alpha]) self.probe_phase_var = blocks.probe_signal_f() self.connect((self.remove_pilot,0), self.phase_var_decim, self.phase_var_arg, self.phase_var_v2s, self.phase_var_mod, (self.phase_var_sub_avg,0), (self.phase_var_sqr,0)) self.connect(self.phase_var_mod, self.phase_var_avg_mod, (self.phase_var_sub_avg,1)) self.connect(self.phase_var_sub_avg, (self.phase_var_sqr,1)) self.connect(self.phase_var_sqr, self.phase_var_avg, self.probe_phase_var) # measure processing rate self.measure_rate = dab.measure_processing_rate(gr.sizeof_gr_complex, 2000000) self.connect(self.input, self.measure_rate) # debugging if debug: self.connect(self.fft, blocks.file_sink(gr.sizeof_gr_complex*dp.fft_length, "debug/ofdm_after_fft.dat")) self.connect((self.cfs,0), blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/ofdm_after_cfs.dat")) self.connect(self.phase_diff, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/ofdm_diff_phasor.dat")) self.connect((self.remove_pilot,0), blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/ofdm_pilot_removed.dat")) self.connect((self.remove_pilot,1), blocks.file_sink(gr.sizeof_char, "debug/ofdm_after_cfs_trigger.dat")) self.connect(self.deinterleave, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/ofdm_deinterleaved.dat")) if self.rp.equalize_magnitude: self.connect(self.equalizer, blocks.file_sink(gr.sizeof_gr_complex*dp.num_carriers, "debug/ofdm_equalizer.dat")) if self.rp.softbits: self.connect(self.softbit_interleaver, blocks.file_sink(gr.sizeof_float*dp.num_carriers*2, "debug/softbits.dat"))
def __init__(self, options):
gr.top_block.__init__(self)
fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
self._u = usrp.source_c(decim_rate=options.decim,
fusb_block_size=fusb_block_size,
fusb_nblocks=fusb_nblocks)
# master clock
if options.fpga_freq is not None:
self._u.set_fpga_master_clock_freq(long(options.fpga_freq))
# default subdev if use didn't pick one
if options.rx_subdev_spec is None:
if u.db(0, 0).dbid() >= 0:
options.rx_subdev_spec = (0, 0)
elif u.db(1, 0).dbid() >= 0:
options.rx_subdev_spec = (1, 0)
else:
options.rx_subdev_spec = (0, 0)
# configure usrp mux
self._u.set_mux(
usrp.determine_rx_mux_value(self._u, options.rx_subdev_spec))
# determine the daughterboard subdevice
self.subdev = usrp.selected_subdev(self._u, options.rx_subdev_spec)
# select antenna
if options.antenna is not None:
print "Selecting antenna %s" % (options.antenna, )
self.subdev.select_rx_antenna(options.antenna)
# set initial values
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
options.gain = float(g[0] + g[1]) / 2
r = self._u.tune(0, self.subdev, options.freq)
self.subdev.set_gain(options.gain)
#sample_rate = options.fpga_clock/options.decim
sample_rate = self._u.adc_freq() / self._u.decim_rate()
symbol_rate = 18000
sps = 2
# output rate will be 36,000
ntaps = 11 * sps
new_sample_rate = symbol_rate * sps
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass,
options.low_pass * 0.1,
gr.firdes.WIN_HANN)
FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps,
options.calibration,
sample_rate)
sys.stderr.write("sample rate: %d\n" % (sample_rate))
DEMOD = cqpsk.cqpsk_demod(samples_per_symbol=sps,
excess_bw=0.35,
costas_alpha=0.03,
gain_mu=0.05,
mu=0.05,
omega_relative_limit=0.05,
log=options.log,
verbose=options.verbose)
OUT = gr.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = gr.fractional_interpolator_cc(0, r)
self.connect(self._u, FILTER, INTERPOLATOR, DEMOD, OUT)
