def test_002_cc(self):
N = 10000 # number of samples to use
fs = 1000 # baseband sampling rate
rrate = 1.123 # resampling rate
freq = 10
data = sig_source_c(fs, freq, 1, N)
signal = blocks.vector_source_c(data)
op = filter.fractional_interpolator_cc(0.0, rrate)
snk = blocks.vector_sink_c()
self.tb.connect(signal, op, snk)
self.tb.run()
Ntest = 5000
L = len(snk.data())
t = map(lambda x: float(x)/(fs/rrate), xrange(L))
phase = 0.1884
expected_data = map(lambda x: math.cos(2.*math.pi*freq*x+phase) + \
1j*math.sin(2.*math.pi*freq*x+phase), t)
dst_data = snk.data()
self.assertComplexTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 3)
def test_002_cc(self):
N = 10000 # number of samples to use
fs = 1000 # baseband sampling rate
rrate = 1.123 # resampling rate
freq = 10
data = sig_source_c(fs, freq, 1, N)
signal = blocks.vector_source_c(data)
op = filter.fractional_interpolator_cc(0.0, rrate)
snk = blocks.vector_sink_c()
self.tb.connect(signal, op, snk)
self.tb.run()
Ntest = 5000
L = len(snk.data())
t = map(lambda x: float(x) / (fs / rrate), xrange(L))
phase = 0.1884
expected_data = map(lambda x: math.cos(2.*math.pi*freq*x+phase) + \
1j*math.sin(2.*math.pi*freq*x+phase), t)
dst_data = snk.data()
self.assertComplexTuplesAlmostEqual(expected_data[-Ntest:],
dst_data[-Ntest:], 3)
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 = blocks.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 = filter.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, filter.firdes.WIN_HANN)
FILTER = filter.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 = blocks.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = filter.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 = filter.interp_fir_filter_ccf(sps, rrc_taps)
self.chn = filter.channel_model(noise, foffset, toffset)
self.off = filter.fractional_interpolator_cc(0.20, 1.0)
if mode == 0:
self.clk = digital.pfb_clock_sync_ccf(sps, gain, rrc_taps_rx,
nfilts, nfilts//2, 3.5)
self.taps = self.clk.taps()
self.dtaps = self.clk.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)
sample_rate = int(options.sample_rate)
self.asrc = audio.source(sample_rate, options.audio_device, True)
self.f2c = blocks.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 = filter.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, filter.firdes.WIN_HANN)
FILTER = filter.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 = blocks.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = filter.fractional_interpolator_cc(0, r)
self.connect(self.f2c, FILTER, INTERPOLATOR, DEMOD, OUT)
def _set_interpolator(self):
interpolator = filter.fractional_interpolator_cc(0, self.sps)
return interpolator
def _set_interpolator(self):
interpolator = filter.fractional_interpolator_cc(0, self.sps)
return interpolator
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="fmReceiver2")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.samp_rep = samp_rep = 44.1e3
self.samp_rate = samp_rate = 2e6
self.freq = freq = 99.3e6
##################################################
# Blocks
##################################################
_freq_sizer = wx.BoxSizer(wx.VERTICAL)
self._freq_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_freq_sizer,
value=self.freq,
callback=self.set_freq,
label="freq",
converter=forms.float_converter(),
proportion=0,
)
self._freq_slider = forms.slider(
parent=self.GetWin(),
sizer=_freq_sizer,
value=self.freq,
callback=self.set_freq,
minimum=87e6,
maximum=108e6,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_freq_sizer)
self.wxgui_waterfallsink2_0 = waterfallsink2.waterfall_sink_f(
self.GetWin(),
baseband_freq=0,
dynamic_range=100,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=512,
fft_rate=15,
average=False,
avg_alpha=None,
title="Waterfall Plot",
)
self.Add(self.wxgui_waterfallsink2_0.win)
self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "" )
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(freq, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_0.set_gain_mode(0, 0)
self.rtlsdr_source_0.set_gain(10, 0)
self.rtlsdr_source_0.set_if_gain(20, 0)
self.rtlsdr_source_0.set_bb_gain(20, 0)
self.rtlsdr_source_0.set_antenna("", 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.low_pass_filter_0 = filter.fir_filter_ccf(1, firdes.low_pass(
1, samp_rate, 75e3, 150e3, firdes.WIN_HAMMING, 6.76))
self.fractional_interpolator_xx_1 = filter.fractional_interpolator_ff(0, 4)
self.fractional_interpolator_xx_0 = filter.fractional_interpolator_cc(0, 3.968)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((4, ))
self.audio_sink_0 = audio.sink(44100, "", True)
self.analog_wfm_rcv_0 = analog.wfm_rcv(
quad_rate=5e5,
audio_decimation=4,
)
self.analog_fm_deemph_0 = analog.fm_deemph(fs=samp_rep, tau=50e-6)
##################################################
# Connections
##################################################
self.connect((self.rtlsdr_source_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.fractional_interpolator_xx_0, 0))
self.connect((self.fractional_interpolator_xx_0, 0), (self.analog_wfm_rcv_0, 0))
self.connect((self.analog_wfm_rcv_0, 0), (self.fractional_interpolator_xx_1, 0))
self.connect((self.fractional_interpolator_xx_1, 0), (self.analog_fm_deemph_0, 0))
self.connect((self.analog_fm_deemph_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.audio_sink_0, 0))
self.connect((self.analog_wfm_rcv_0, 0), (self.wxgui_waterfallsink2_0, 0))
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 = blocks.vector_to_stream(gr.sizeof_float, 142)
self.ifreq = options.frequency
self.rfgain = options.gain
self.src = osmosdr.source(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 = firdes.low_pass(1.0, sample_rate, 145e3, 10e3, firdes.WIN_HANN)
self.tuner = freq_xlating_fir_filter_ccf(1, taps, self.offset,
sample_rate)
self.interpolator = 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 = blocks.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, 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 = blocks.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 = filter.firdes.low_pass(1.0, sample_rate,
options.low_pass,
options.low_pass * 0.1,
filter.firdes.WIN_HANN)
FILTER = filter.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 = blocks.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = filter.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, 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 = firdes.low_pass(1.0, sample_rate, options.low_pass,
options.low_pass * 0.1, firdes.WIN_HANN)
FILTER = filter.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 = blocks.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = filter.fractional_interpolator_cc(0, r)
self.connect(self._u, FILTER, INTERPOLATOR, DEMOD, OUT)
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 = blocks.vector_to_stream(gr.sizeof_float, 142)
self.ifreq = options.frequency
self.rfgain = options.gain
self.src = osmosdr.source(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 = firdes.low_pass(1.0, sample_rate, 145e3, 10e3, firdes.WIN_HANN)
self.tuner = filter.freq_xlating_fir_filter_ccf(1, taps, self.offset, sample_rate)
self.interpolator = filter.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 = blocks.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,
N,
sps,
rolloff,
ntaps,
bw,
noise,
foffset,
toffset,
poffset,
mode=0):
gr.top_block.__init__(self)
rrc_taps = filter.firdes.root_raised_cosine(sps, sps, 1.0, rolloff,
ntaps)
gain = 2 * scipy.pi / 100.0
nfilts = 32
rrc_taps_rx = filter.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 = blocks.vector_source_c(data.tolist(), False)
self.rrc = filter.interp_fir_filter_ccf(sps, rrc_taps)
self.chn = channels.channel_model(noise, foffset, toffset)
self.off = filter.fractional_interpolator_cc(0.20, 1.0)
if mode == 0:
self.clk = digital.pfb_clock_sync_ccf(sps, gain, rrc_taps_rx,
nfilts, nfilts // 2, 3.5)
self.taps = self.clk.taps()
self.dtaps = self.clk.diff_taps()
self.vsnk_err = blocks.vector_sink_f()
self.vsnk_rat = blocks.vector_sink_f()
self.vsnk_phs = blocks.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 = blocks.vector_sink_f()
self.connect((self.clk, 1), self.vsnk_err)
self.vsnk_src = blocks.vector_sink_c()
self.vsnk_clk = blocks.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 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 = firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, firdes.WIN_HANN)
FILTER = filter.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 = blocks.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = filter.fractional_interpolator_cc(0, r)
self.connect(self._u, FILTER, INTERPOLATOR, DEMOD, OUT)
