def test_five_fft_filter():
top = gr.top_block()
src = blocks.null_source(gr.sizeof_gr_complex)
filters = [filter.fft_filter_ccf(1, [random.random() for j in range(256)]) for i in range(5)]
probe = blocks.probe_rate(gr.sizeof_gr_complex)
top.connect(*([src] + filters + [probe]))
return top, probe
def test_fft_filter_ccf():
top = gr.top_block()
src = blocks.null_source(gr.sizeof_gr_complex)
firfilter = filter.fft_filter_ccf(1, [random.random() for _ in range(128)])
probe = blocks.probe_rate(gr.sizeof_gr_complex)
top.connect(src, firfilter, probe)
return top, probe
def test_five_fft_filter():
top = gr.top_block()
src = blocks.null_source(gr.sizeof_gr_complex)
filters = [filter.fft_filter_ccf(1, [random.random() for j in range(256)]) for i in range(5)]
probe = blocks.probe_rate(gr.sizeof_gr_complex)
top.connect(*([src] + filters + [probe]))
return top, probe
def test_fft_filter_ccf():
top = gr.top_block()
src = blocks.null_source(gr.sizeof_gr_complex)
firfilter = filter.fft_filter_ccf(1, [random.random() for _ in range(128)])
probe = blocks.probe_rate(gr.sizeof_gr_complex)
top.connect(src, firfilter, probe)
return top, probe
def test_ccf_003(self):
tb = gr.top_block()
src_data = (0,1,2,3,4,5,6,7)
taps = (2,)
expected_result = tuple([2 * complex(x) for x in (0,1,2,3,4,5,6,7)])
src = blocks.vector_source_c(src_data)
op = filter.fft_filter_ccf(1, taps)
dst = blocks.vector_sink_c()
tb.connect(src, op, dst)
tb.run()
result_data = dst.data()
#print 'expected:', expected_result
#print 'results: ', result_data
self.assertComplexTuplesAlmostEqual (expected_result, result_data, 5)
def test_ccf_003(self):
tb = gr.top_block()
src_data = (0,1,2,3,4,5,6,7)
taps = (2,)
expected_result = tuple([2 * complex(x) for x in (0,1,2,3,4,5,6,7)])
src = blocks.vector_source_c(src_data)
op = filter.fft_filter_ccf(1, taps)
dst = blocks.vector_sink_c()
tb.connect(src, op, dst)
tb.run()
result_data = dst.data()
#print 'expected:', expected_result
#print 'results: ', result_data
self.assertComplexTuplesAlmostEqual (expected_result, result_data, 5)
def __init__(self,
samp_rate_hz,
sps,
SF,
shr,
filtered_preamble_code,
alpha=1e-3,
beta=5,
time_gap_chips=11,
max_offset_hz=0,
max_num_filters=1,
output_correlator_index=0):
gr.hier_block2.__init__(
self,
"SpaRSe_synchronization_cc",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature3(3, 3, gr.sizeof_gr_complex, gr.sizeof_gr_complex,
gr.sizeof_float)) # Output signature
self.delta_phi = lpwan.SpaRSe_utils.calculate_phase_increments(
samp_rate_hz, SF, sps, max_offset_hz, max_num_filters)
# Define blocks
self.rotators = [blocks.rotator_cc(-phi) for phi in self.delta_phi]
self.matched_filters = [
filter.fft_filter_ccf(1,
np.flipud(np.conj(filtered_preamble_code)))
for i in xrange(len(self.delta_phi))
]
self.preamble_detector = preamble_detector_cc(shr, sps, SF,
time_gap_chips, alpha,
beta, self.delta_phi,
output_correlator_index)
self.skiphead = blocks.skiphead(
gr.sizeof_gr_complex,
sps * (SF + time_gap_chips) +
4) # the +4 is "empirical" but well tested for sps=4
# Connect blocks with preamble detector and outputs
for i in xrange(len(self.delta_phi)):
self.connect(self, self.rotators[i], self.matched_filters[i],
(self.preamble_detector, i))
self.connect(self, self.skiphead,
(self.preamble_detector, len(self.delta_phi)))
for i in xrange(3):
self.connect((self.preamble_detector, i), (self, i))
def test_ccf_004(self):
random.seed(0)
for i in range(25):
# sys.stderr.write("\n>>> Loop = %d\n" % (i,))
src_len = 4*1024
src_data = make_random_complex_tuple(src_len)
ntaps = int(random.uniform(2, 1000))
taps = make_random_float_tuple(ntaps)
expected_result = reference_filter_ccf(1, taps, src_data)
src = blocks.vector_source_c(src_data)
op = filter.fft_filter_ccf(1, taps)
dst = blocks.vector_sink_c()
tb = gr.top_block()
tb.connect(src, op, dst)
tb.run()
result_data = dst.data()
del tb
self.assert_fft_ok2(expected_result, result_data)
def test_ccf_004(self):
random.seed(0)
for i in range(25):
# sys.stderr.write("\n>>> Loop = %d\n" % (i,))
src_len = 4*1024
src_data = make_random_complex_tuple(src_len)
ntaps = int(random.uniform(2, 1000))
taps = make_random_float_tuple(ntaps)
expected_result = reference_filter_ccf(1, taps, src_data)
src = blocks.vector_source_c(src_data)
op = filter.fft_filter_ccf(1, taps)
dst = blocks.vector_sink_c()
tb = gr.top_block()
tb.connect(src, op, dst)
tb.run()
result_data = dst.data()
del tb
self.assert_fft_ok2(expected_result, result_data)
def __init__(self):
gr.top_block.__init__(self, "atcs")
Qt.QWidget.__init__(self)
self.setWindowTitle("atcs")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "atcs")
try:
if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"):
self.restoreGeometry(self.settings.value("geometry").toByteArray())
else:
self.restoreGeometry(self.settings.value("geometry"))
except:
pass
##################################################
# Variables
##################################################
self.symbol_rate = symbol_rate = 10762200
self.samp_rate = samp_rate = 32000
self.center_freq = center_freq = 429000000
##################################################
# Blocks
##################################################
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
1024, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
center_freq, #fc
samp_rate, #bw
"", #name
1
)
self.qtgui_freq_sink_x_0.set_update_time(0.10)
self.qtgui_freq_sink_x_0.set_y_axis(-140, 10)
self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB')
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.qtgui_freq_sink_x_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0.enable_grid(False)
self.qtgui_freq_sink_x_0.set_fft_average(1.0)
self.qtgui_freq_sink_x_0.enable_axis_labels(True)
self.qtgui_freq_sink_x_0.enable_control_panel(False)
labels = ['', '', '', '', '',
'', '', '', '', '']
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "dark blue"]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in range(1):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_win)
self.fft_filter_xxx_0 = filter.fft_filter_ccf(1, firdes.root_raised_cosine(0.11, symbol_rate, symbol_rate/2, 0.1152, 200), 1)
self.fft_filter_xxx_0.declare_sample_delay(0)
self.dtv_dvbs2_modulator_bc_0 = dtv.dvbs2_modulator_bc(
dtv.FECFRAME_NORMAL,
dtv.C1_4,
dtv.MOD_8VSB,
dtv.INTERPOLATION_OFF)
self.dtv_atsc_trellis_encoder_0 = dtv.atsc_trellis_encoder()
self.dtv_atsc_rs_encoder_0 = dtv.atsc_rs_encoder()
self.dtv_atsc_randomizer_0 = dtv.atsc_randomizer()
self.dtv_atsc_pad_0 = dtv.atsc_pad()
self.dtv_atsc_interleaver_0 = dtv.atsc_interleaver()
self.dtv_atsc_field_sync_mux_0 = dtv.atsc_field_sync_mux()
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_char*1, 1024)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, symbol_rate,True)
self.blocks_rotator_cc_0 = blocks.rotator_cc(-1.5708)
self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_char, 832, 1024, 0)
self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char*1, '/home/supernode/Downloads/Glen.ts', True, 0, 0)
self.blocks_file_source_0.set_begin_tag(pmt.PMT_NIL)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex*1, '/home/supernode/Work/microwave_experiments/signal_block/mantap.ts', False)
self.blocks_file_sink_0.set_unbuffered(False)
##################################################
# Connections
##################################################
self.connect((self.blocks_file_source_0, 0), (self.dtv_atsc_pad_0, 0))
self.connect((self.blocks_keep_m_in_n_0, 0), (self.dtv_dvbs2_modulator_bc_0, 0))
self.connect((self.blocks_rotator_cc_0, 0), (self.fft_filter_xxx_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.qtgui_freq_sink_x_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_keep_m_in_n_0, 0))
self.connect((self.dtv_atsc_field_sync_mux_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.dtv_atsc_interleaver_0, 0), (self.dtv_atsc_trellis_encoder_0, 0))
self.connect((self.dtv_atsc_pad_0, 0), (self.dtv_atsc_randomizer_0, 0))
self.connect((self.dtv_atsc_randomizer_0, 0), (self.dtv_atsc_rs_encoder_0, 0))
self.connect((self.dtv_atsc_rs_encoder_0, 0), (self.dtv_atsc_interleaver_0, 0))
self.connect((self.dtv_atsc_trellis_encoder_0, 0), (self.dtv_atsc_field_sync_mux_0, 0))
self.connect((self.dtv_dvbs2_modulator_bc_0, 0), (self.blocks_rotator_cc_0, 0))
self.connect((self.fft_filter_xxx_0, 0), (self.blocks_throttle_0, 0))
def __init__(self,
input_rate=None,
demod_type='cqpsk',
relative_freq=0,
offset=0,
if_rate=_def_if_rate,
gain_mu=_def_gain_mu,
costas_alpha=_def_costas_alpha,
symbol_rate=_def_symbol_rate):
"""
Hierarchical block for P25 demodulation.
The complex input is tuned, decimated and demodulated
@param input_rate: sample rate of complex input channel
@type input_rate: int
"""
gr.hier_block2.__init__(
self,
"p25_demod_cb",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_char)) # Output signature
# gr.io_signature(0, 0, 0)) # Output signature
p25_demod_base.__init__(self, if_rate=if_rate, symbol_rate=symbol_rate)
self.input_rate = input_rate
self.if_rate = if_rate
self.symbol_rate = symbol_rate
self.connect_state = None
self.offset = 0
self.sps = 0.0
self.lo_freq = 0
self.float_sink = None
self.complex_sink = None
# local osc
self.lo = analog.sig_source_c(input_rate, analog.GR_SIN_WAVE, 0, 1.0,
0)
self.mixer = blocks.multiply_cc()
lpf_coeffs = filter.firdes.low_pass(1.0, input_rate, 7250, 1450,
filter.firdes.WIN_HANN)
decimation = int(input_rate / if_rate)
if hasattr(filter, "fft_filter_ccf"):
self.lpf = filter.fft_filter_ccf(decimation, lpf_coeffs)
else:
self.lpf = filter.fir_filter_ccf(decimation, lpf_coeffs)
resampled_rate = float(input_rate) / float(
decimation) # rate at output of self.lpf
self.arb_resampler = filter.pfb.arb_resampler_ccf(
float(self.if_rate) / resampled_rate)
self.connect(self, (self.mixer, 0))
self.connect(self.lo, (self.mixer, 1))
self.connect(self.mixer, self.lpf, self.arb_resampler)
levels = [-2.0, 0.0, 2.0, 4.0]
self.slicer = op25_repeater.fsk4_slicer_fb(levels)
omega = float(self.if_rate) / float(self.symbol_rate)
gain_omega = 0.1 * gain_mu * gain_mu
alpha = costas_alpha
beta = 0.125 * alpha * alpha
fmax = 2400 # Hz
fmax = 2 * pi * fmax / float(self.if_rate)
self.clock = op25_repeater.gardner_costas_cc(omega, gain_mu,
gain_omega, alpha, beta,
fmax, -fmax)
self.agc = analog.feedforward_agc_cc(16, 1.0)
# Perform Differential decoding on the constellation
self.diffdec = digital.diff_phasor_cc()
# take angle of the difference (in radians)
self.to_float = blocks.complex_to_arg()
# convert from radians such that signal is in -3/-1/+1/+3
self.rescale = blocks.multiply_const_ff((1 / (pi / 4)))
# fm demodulator (needed in fsk4 case)
fm_demod_gain = if_rate / (2.0 * pi * _def_symbol_deviation)
self.fm_demod = analog.quadrature_demod_cf(fm_demod_gain)
self.connect_chain(demod_type)
self.connect(self.slicer, self)
self.set_relative_frequency(relative_freq)
