def __init__(self):
gr.top_block.__init__(self)
#rt = gr.enable_realtime_scheduling()
######## Variables #########
self.dac_rate = 1e6 # DAC rate
self.adc_rate = 100e6 / 50 # ADC rate (2MS/s complex samples)
self.decim = 1 # Decimation (downsampling factor)
self.ampl = 0.55 # Output signal amplitude (signal power vary for different RFX900 cards)
self.freq = 910e6 # Modulation frequency (can be set between 902-920)
self.rx_gain = 0 # RX Gain (gain at receiver)
self.tx_gain = 20 # RFX900 no Tx gain option
self.usrp_address_source = "addr=192.168.1.2,recv_frame_size=256"
self.usrp_address_sink = "addr=192.168.1.2,recv_frame_size=256"
# Each FM0 symbol consists of ADC_RATE/BLF samples (2e6/40e3 = 50 samples)
# 10 samples per symbol after matched filtering and decimation
self.num_taps = [1] * 1 # matched to half symbol period
######## File sinks for debugging (1 for each block) #########
self.file_sink_source = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/source", False)
self.file_sink_matched_filter = blocks.file_sink(
gr.sizeof_gr_complex * 1, "../misc/data/matched_filter", False)
self.file_sink_gate = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/gate", False)
self.file_sink_decoder = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/decoder",
False)
self.file_sink_reader = blocks.file_sink(gr.sizeof_float * 1,
"../misc/data/reader", False)
self.file_sink = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/file_sink",
False) ## instead of uhd.usrp_sink
######## Blocks #########
self.matched_filter = filter.fir_filter_ccc(self.decim, self.num_taps)
self.gate = rfid.gate(int(self.adc_rate / self.decim))
self.tag_decoder = rfid.tag_decoder(int(self.adc_rate / self.decim))
self.reader = rfid.reader(int(self.adc_rate / self.decim),
int(self.dac_rate))
self.amp = blocks.multiply_const_ff(self.ampl)
self.to_complex = blocks.float_to_complex()
if (DEBUG == False): # Real Time Execution
# USRP blocks
self.u_source()
self.u_sink()
######## Connections #########
self.connect(self.source, self.matched_filter)
self.connect(self.matched_filter, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder, 0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, self.sink)
#File sinks for logging (Remove comments to log data)
self.connect(self.source, self.file_sink_source)
self.connect(self.to_complex, self.file_sink)
else: # Offline Data
self.file_source = blocks.file_source(
gr.sizeof_gr_complex * 1, "../misc/data/file_source",
False) ## instead of uhd.usrp_source
#self.file_sink = blocks.file_sink(gr.sizeof_gr_complex*1, "../misc/data/file_sink", False) ## instead of uhd.usrp_sink
######## Connections #########
self.connect(self.file_source, self.matched_filter)
self.connect(self.matched_filter, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder, 0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, self.file_sink)
#File sinks for logging
self.connect(self.gate, self.file_sink_gate)
self.connect((self.tag_decoder, 1),
self.file_sink_decoder) # (Do not comment this line)
#self.connect(self.file_sink_reader, self.file_sink_reader)
self.connect(self.matched_filter, self.file_sink_matched_filter)
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
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", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.tx_gain = tx_gain = 0
self.rx_gain = rx_gain = 20
self.num_taps = num_taps = [1] * 25
self.freq = freq = 910e6
self.decim = decim = 5
self.dac_rate = dac_rate = 1e6
self.ampl = ampl = 0.1
self.adc_rate = adc_rate = 2e6
##################################################
# Blocks
##################################################
self.rfid_tag_decoder_0 = rfid.tag_decoder(int(adc_rate/decim))
self.rfid_reader_0 = rfid.reader(int(adc_rate/decim), int(dac_rate))
self.rfid_gate_0 = rfid.gate(int(adc_rate / decim))
self.fir_filter_xxx_0 = filter.fir_filter_ccc(decim, (num_taps))
self.fir_filter_xxx_0.declare_sample_delay(0)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, 3 * int(adc_rate/decim),True)
self.blocks_multiply_const_xx_0 = blocks.multiply_const_ff(ampl)
self.blocks_float_to_complex_0 = blocks.float_to_complex(1)
self.blocks_file_source_0 = blocks.file_source(gr.sizeof_gr_complex*1, '/home/andreas/PartIIB/Repos/rfid/Gen2-UHF-RFID-Reader/gr-rfid/misc/data/file_source_test', False)
self.blocks_file_sink_2 = blocks.file_sink(gr.sizeof_gr_complex*1, '/home/andreas/PartIIB/Repos/rfid/Gen2-UHF-RFID-Reader/gr-rfid/misc/data/decoder', False)
self.blocks_file_sink_2.set_unbuffered(False)
self.blocks_file_sink_1 = blocks.file_sink(gr.sizeof_gr_complex*1, '/home/andreas/PartIIB/Repos/rfid/Gen2-UHF-RFID-Reader/gr-rfid/misc/data/matched_filter', False)
self.blocks_file_sink_1.set_unbuffered(False)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex*1, '/home/andreas/PartIIB/Repos/rfid/Gen2-UHF-RFID-Reader/gr-rfid/misc/data/file_sink', False)
self.blocks_file_sink_0.set_unbuffered(False)
##################################################
# Connections
##################################################
self.connect((self.blocks_file_source_0, 0), (self.fir_filter_xxx_0, 0))
self.connect((self.blocks_float_to_complex_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_multiply_const_xx_0, 0), (self.blocks_float_to_complex_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.rfid_gate_0, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.blocks_file_sink_1, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.rfid_gate_0, 0), (self.rfid_tag_decoder_0, 0))
self.connect((self.rfid_reader_0, 0), (self.blocks_multiply_const_xx_0, 0))
self.connect((self.rfid_tag_decoder_0, 1), (self.blocks_file_sink_2, 0))
self.connect((self.rfid_tag_decoder_0, 0), (self.rfid_reader_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
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", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.tx_gain = tx_gain = 0
self.rx_gain = rx_gain = 20
self.num_taps = num_taps = [1] * 25
self.freq = freq = 910e6
self.decim = decim = 5
self.dac_rate = dac_rate = 5e6
self.ampl = ampl = 0.1
self.adc_rate = adc_rate = 5e6
##################################################
# Blocks
##################################################
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("addr=192.168.10.2", "recv_frame_size=256")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(adc_rate)
self.uhd_usrp_source_0.set_center_freq(910000000, 0)
self.uhd_usrp_source_0.set_gain(15, 0)
self.uhd_usrp_source_0.set_antenna("RX2", 0)
self.uhd_usrp_sink_0 = uhd.usrp_sink(
",".join(("addr=192.168.10.2", "recv_frame_size=256")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0.set_samp_rate(dac_rate)
self.uhd_usrp_sink_0.set_center_freq(910000000, 0)
self.uhd_usrp_sink_0.set_gain(15, 0)
self.uhd_usrp_sink_0.set_antenna("TX/RX", 0)
self.rfid_tag_decoder_0 = rfid.tag_decoder(int(adc_rate / decim))
self.rfid_reader_0 = rfid.reader(int(adc_rate / decim), int(dac_rate))
self.rfid_gate_0 = rfid.gate(int(adc_rate / decim))
self.low_pass_filter_0 = filter.fir_filter_ccf(
decim,
firdes.low_pass(1, adc_rate, 50000, 10000, firdes.WIN_HAMMING,
6.76))
self.interp_fir_filter_xxx_0 = filter.interp_fir_filter_fff(10, ([1]))
self.interp_fir_filter_xxx_0.declare_sample_delay(0)
self.fir_filter_xxx_0 = filter.fir_filter_ccc(decim, (num_taps))
self.fir_filter_xxx_0.declare_sample_delay(0)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_gr_complex * 1)
self.blocks_multiply_xx_0_0 = blocks.multiply_vcc(1)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_float_to_complex_0_0 = blocks.float_to_complex(1)
self.blocks_file_sink_2 = blocks.file_sink(
gr.sizeof_gr_complex * 1,
"/home/cna22/Desktop/Testdata/decoder_carl_test", False)
self.blocks_file_sink_2.set_unbuffered(False)
self.blocks_file_sink_0_0_0 = blocks.file_sink(
gr.sizeof_gr_complex * 1,
"/home/cna22/git/Distributed-Gen2-UHF-RFID-Reader/gr-rfid/misc/data/source",
False)
self.blocks_file_sink_0_0_0.set_unbuffered(False)
self.blocks_file_sink_0_0 = blocks.file_sink(
gr.sizeof_gr_complex * 1,
"/home/cna22/git/Distributed-Gen2-UHF-RFID-Reader/gr-rfid/misc/data/filter",
False)
self.blocks_file_sink_0_0.set_unbuffered(False)
self.blocks_file_sink_0 = blocks.file_sink(
gr.sizeof_float * 1,
"/home/cna22/git/Distributed-Gen2-UHF-RFID-Reader/gr-rfid/misc/data/reader",
False)
self.blocks_file_sink_0.set_unbuffered(False)
self.analog_sig_source_x_0_1_0 = analog.sig_source_c(
dac_rate, analog.GR_COS_WAVE, 2000000, 1, 0)
self.analog_sig_source_x_0_1 = analog.sig_source_c(
dac_rate, analog.GR_COS_WAVE, 2000000, 3, 0)
##################################################
# Connections
##################################################
self.connect((self.analog_sig_source_x_0_1, 0),
(self.blocks_multiply_xx_0, 1))
self.connect((self.analog_sig_source_x_0_1_0, 0),
(self.blocks_multiply_xx_0_0, 1))
self.connect((self.blocks_float_to_complex_0_0, 0),
(self.blocks_multiply_xx_0, 0))
self.connect((self.blocks_multiply_xx_0, 0), (self.uhd_usrp_sink_0, 0))
self.connect((self.blocks_multiply_xx_0_0, 0),
(self.low_pass_filter_0, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.blocks_file_sink_2, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.rfid_gate_0, 0))
self.connect((self.interp_fir_filter_xxx_0, 0),
(self.blocks_float_to_complex_0_0, 0))
self.connect((self.low_pass_filter_0, 0),
(self.blocks_file_sink_0_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.fir_filter_xxx_0, 0))
self.connect((self.rfid_gate_0, 0), (self.rfid_tag_decoder_0, 0))
self.connect((self.rfid_reader_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.rfid_reader_0, 0),
(self.interp_fir_filter_xxx_0, 0))
self.connect((self.rfid_tag_decoder_0, 1),
(self.blocks_null_sink_0, 0))
self.connect((self.rfid_tag_decoder_0, 0), (self.rfid_reader_0, 0))
self.connect((self.uhd_usrp_source_0, 0),
(self.blocks_file_sink_0_0_0, 0))
self.connect((self.uhd_usrp_source_0, 0),
(self.blocks_multiply_xx_0_0, 0))
def __init__(self):
gr.top_block.__init__(self)
self.dac_rate = 1e6 # DAC rate
self.adc_rate = 100e6 / 50 # ADC rate (2MS/s complex samples)
self.decim = 5 # Decimation (downsampling factor)
self.ampl = 0.2 # Output signal amplitude (signal power vary for different RFX900 cards)
self.freq = 915e6 # Modulation frequency (can be set between 902-920)
self.rx_gain = 20 # RX Gain (gain at receiver)
self.tx_gain = 20 # RFX900 no Tx gain option
self.usrp_address_source = "addr=192.168.10.2,recv_frame_size=256"
self.usrp_address_sink = "addr=192.168.10.2,recv_frame_size=256"
# Each FM0 symbol consists of ADC_RATE/BLF samples (2e6/40e3 = 50 samples)
# 10 samples per symbol after matched filtering and decimation
self.num_taps = [1] * 25 # matched to half symbol period
self.matched_filter = filter.fir_filter_ccc(self.decim, self.num_taps);
self.gate = rfid.gate(int(self.adc_rate / self.decim))
self.tag_decoder = rfid.tag_decoder(int(self.adc_rate / self.decim))
self.reader = rfid.reader(int(self.adc_rate / self.decim), int(self.dac_rate))
self.amp = blocks.multiply_const_ff(self.ampl)
self.to_complex = blocks.float_to_complex()
self.file_sink_decoder = blocks.file_sink(gr.sizeof_gr_complex * 1, "../misc/data/decoder", False)
self.u_source()
self.u_sink()
# QT
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
# time sink
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", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
rt = gr.enable_realtime_scheduling()
self.qtgui_time_sink = qtgui.time_sink_c(
1024, # size
self.adc_rate, # samp_rate
"", # name
1 # number of inputs
)
self.qtgui_time_sink.set_update_time(0.01)
self.qtgui_time_sink.set_y_axis(0, 10)
self.qtgui_time_sink.set_y_label('Amplitude', "")
self.qtgui_time_sink.enable_tags(-1, True)
self.qtgui_time_sink.set_trigger_mode(qtgui.TRIG_MODE_AUTO, qtgui.TRIG_SLOPE_POS, 1, 0, 0, "")
self.qtgui_time_sink.enable_autoscale(True)
self.qtgui_time_sink.enable_grid(True)
self.qtgui_time_sink.enable_axis_labels(True)
self.qtgui_time_sink.enable_control_panel(True)
if not True:
self.qtgui_time_sink.disable_legend()
labels = ['', '', '', '', '',
'', '', '', '', '']
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "blue"]
styles = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1,
-1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2 * 1):
if len(labels[i]) == 0:
if (i % 2 == 0):
self.qtgui_time_sink.set_line_label(i, "Re{{Data {0}}}".format(i / 2))
else:
self.qtgui_time_sink.set_line_label(i, "Im{{Data {0}}}".format(i / 2))
else:
self.qtgui_time_sink.set_line_label(i, labels[i])
self.qtgui_time_sink.set_line_width(i, widths[i])
self.qtgui_time_sink.set_line_color(i, colors[i])
self.qtgui_time_sink.set_line_style(i, styles[i])
self.qtgui_time_sink.set_line_marker(i, markers[i])
self.qtgui_time_sink.set_line_alpha(i, alphas[i])
# consollation
self._qtgui_time_sink_win = sip.wrapinstance(self.qtgui_time_sink.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_time_sink_win)
self.qtgui_const_sink_x_0 = qtgui.const_sink_c(
1024, # size
"", # name
1 # number of inputs
)
self.qtgui_const_sink_x_0.set_update_time(0.10)
self.qtgui_const_sink_x_0.set_y_axis(-2, 2)
self.qtgui_const_sink_x_0.set_x_axis(-2, 2)
self.qtgui_const_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, "")
self.qtgui_const_sink_x_0.enable_autoscale(True)
self.qtgui_const_sink_x_0.enable_grid(True)
self.qtgui_const_sink_x_0.enable_axis_labels(True)
if not True:
self.qtgui_const_sink_x_0.disable_legend()
labels = ['', '', '', '', '',
'', '', '', '', '']
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "red", "red", "red",
"red", "red", "red", "red", "red"]
styles = [0, 0, 0, 0, 0,
0, 0, 0, 0, 0]
markers = [0, 0, 0, 0, 0,
0, 0, 0, 0, 0]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_const_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_const_sink_x_0.set_line_label(i, labels[i])
self.qtgui_const_sink_x_0.set_line_width(i, widths[i])
self.qtgui_const_sink_x_0.set_line_color(i, colors[i])
self.qtgui_const_sink_x_0.set_line_style(i, styles[i])
self.qtgui_const_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_const_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_const_sink_x_0_win = sip.wrapinstance(self.qtgui_const_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_const_sink_x_0_win)
self.file_sink_source = blocks.file_sink(gr.sizeof_gr_complex*1, "../misc/data/source", True)
self.file_sink_matched_filter = blocks.file_sink(gr.sizeof_gr_complex*1, "../misc/data/matched_filter", True)
self.file_sink_gate = blocks.file_sink(gr.sizeof_gr_complex*1, "../misc/data/gate", True)
self.file_sink_decoder = blocks.file_sink(gr.sizeof_gr_complex*1, "../misc/data/decoder", True)
self.file_sink_reader = blocks.file_sink(gr.sizeof_float*1, "../misc/data/reader", True)
# CONNECTION
self.connect((self.gate, 0), (self.qtgui_const_sink_x_0, 0))
self.connect((self.gate,0), (self.qtgui_time_sink, 0))
self.connect(self.source, self.matched_filter)
self.connect(self.matched_filter, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder,0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, self.sink)
# log
self.connect(self.source, self.file_sink_source)
self.connect((self.tag_decoder,1), self.file_sink_decoder) # (Do not comment this line)
self.connect(self.gate, self.file_sink_gate)
self.connect(self.matched_filter, self.file_sink_matched_filter)
def closeEvent(self, event):
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.settings.setValue("geometry", self.saveGeometry())
event.accept()
def __init__(self):
gr.top_block.__init__(self)
#rt = gr.enable_realtime_scheduling()
# Adam Laurie
self.select = True # set to True to use SELECT before initial QUERY
#self.mask = '111' # SELECT bit mask (up to 256 bits, e.g. '10100'). empty mask matches all tags.
self.mask = ''
######## Variables #########
self.dac_rate = 1e6 # DAC rate
self.adc_rate = 100e6 / 50 # ADC rate (2MS/s complex samples)
self.decim = 5 # Decimation (downsampling factor)
# min seems to be .3 with max TX gain (60)
# max is .7
self.ampl = 1 # Output signal amplitude (signal power vary for different RFX900 cards)
self.freq = 868e6 # Modulation frequency (can be set between 865.6 - 867.6 or 915 - 921 in UK)
# see https://www.gs1.org/sites/default/files/docs/epc/uhf_regulations.pdf
#self.freq = 910e6 # Modulation frequency (can be set between 902-920)
self.rx_gain = 6 # overall gain - libbladerf2.0 will figure it out!
self.tx_gain = 60 # note that a setting of '0' will be ignored!!
# Each FM0 symbol consists of ADC_RATE/BLF samples (2e6/40e3 = 50 samples)
# 10 samples per symbol after matched filtering and decimation
self.num_taps = [1] * 25 # matched to half symbol period
######## File sinks for debugging (1 for each block) #########
self.file_sink_source = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/source", False)
self.file_sink_matched_filter = blocks.file_sink(
gr.sizeof_gr_complex * 1, "../misc/data/matched_filter", False)
self.file_sink_gate = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/gate", False)
self.file_sink_decoder = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/decoder",
False)
self.file_sink_reader = blocks.file_sink(gr.sizeof_float * 1,
"../misc/data/reader", False)
######## Blocks #########
self.matched_filter = filter.fir_filter_ccc(self.decim, self.num_taps)
self.gate = rfid.gate(int(self.adc_rate / self.decim))
self.tag_decoder = rfid.tag_decoder(int(self.adc_rate / self.decim))
self.reader = rfid.reader(int(self.adc_rate / self.decim),
int(self.dac_rate), self.select, self.mask)
self.amp = blocks.multiply_const_ff(self.ampl)
self.to_complex = blocks.float_to_complex()
if (DEBUG == False): # Real Time Execution
# USRP blocks
self.u_source()
self.u_sink()
######## Connections #########
self.connect(self.source, self.matched_filter)
self.connect(self.matched_filter, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder, 0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
# addy - comment out and sink to /dev/null for sniff mode
self.connect(self.to_complex, self.sink)
#self.file_sink = blocks.file_sink(gr.sizeof_gr_complex*1, "/dev/null", False)
#self.connect(self.to_complex, self.file_sink)
#File sinks for logging (Remove comments to log data)
self.connect(self.source, self.file_sink_source)
else: # Offline Data
self.file_source = blocks.file_source(
gr.sizeof_gr_complex * 1, "../misc/data/file_source_test",
False) ## instead of uhd.usrp_source
self.file_sink = blocks.file_sink(
gr.sizeof_gr_complex * 1, "../misc/data/file_sink",
False) ## instead of uhd.usrp_sink
######## Connections #########
self.connect(self.file_source, self.matched_filter)
self.connect(self.matched_filter, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder, 0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, self.file_sink)
#File sinks for logging
#self.connect(self.gate, self.file_sink_gate)
self.connect((self.tag_decoder, 1),
self.file_sink_decoder) # (Do not comment this line)
def __init__(self):
gr.top_block.__init__(self)
rt = gr.enable_realtime_scheduling()
######## Variables #########
self.dac_rate = 2e6 # DAC rate
self.adc_rate = 2e6 # ADC rate (2MS/s complex samples)
self.decim = 5 # Decimation (downsampling factor)
self.ampl = 0.5 # Output signal amplitude (signal power vary for different RFX900 cards)
# Modulation frequency (can be set between 902-920)
self.tx_freq_1 = args.freq1 * 1e6
# Modulation frequency (can be set between 902-920)
self.tx_freq_2 = args.freq2 * 1e6
self.rx_gain = 20 # RX Gain (gain at receiver)
self.tx_gain_1 = args.pow1 # RFX900 no Tx gain option
self.tx_gain_2 = args.pow2 # RFX900 no Tx gain option
if args.single_tx:
self.usrp_address_source = "addr=192.168.10.2,recv_frame_size=256"
self.usrp_address_sink = "addr=192.168.10.2,recv_frame_size=256"
else:
self.usrp_address_source = "addr0=192.168.10.2, addr1=192.168.20.2,recv_frame_size=256"
self.usrp_address_sink = "addr0=192.168.10.2, addr1=192.168.20.2,recv_frame_size=256"
# Each FM0 symbol consists of ADC_RATE/BLF samples (2e6/40e3 = 50 samples)
# 10 samples per symbol after matched filtering and decimation
self.num_taps = [1] * 2 * int(
self.adc_rate /
(2 * 2 * 40e3 * self.decim)) # matched to half symbol period
# Take half, round then double to ensure even number.
print("Half symbol length is ",
2 * int(self.adc_rate / (2 * 2 * 40e3 * self.decim)))
######## File sinks for debugging (1 for each block) #########
self.file_sink_source = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/source", False)
self.file_sink_matched_filter = blocks.file_sink(
gr.sizeof_gr_complex * 1, "../misc/data/matched_filter", False)
self.file_sink_gate = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/gate", False)
self.file_sink_decoder = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/decoder",
False)
self.file_sink_reader = blocks.file_sink(gr.sizeof_float * 1,
"../misc/data/reader", False)
self.file_sink_sink = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/sink", False)
if args.delay_n:
self.delay = blocks.delay(gr.sizeof_gr_complex * 1, args.delay_n)
######## Blocks #########
#self.low_pass = filter.fir_filter_ccc(self.decim, self.num_taps);
self.low_pass = filter.fir_filter_ccf(
self.decim,
firdes.low_pass(1, self.adc_rate, 200000, 100000,
firdes.WIN_HAMMING, 6.76))
#self.low_pass = filter.fir_filter_ccf(5, firdes.low_pass(1, self.adc_rate,
#50000, 50000, firdes.WIN_HAMMING, 6.76))
self.gate = rfid.gate(int(self.adc_rate / self.decim))
self.tag_decoder = rfid.tag_decoder(int(self.adc_rate / self.decim))
if args.fake_data == '0.5':
self.reader = blocks.file_source(
gr.sizeof_float * 1, "../misc/data/file_reader_test_0.5M",
False)
elif args.fake_data == '1':
self.reader = blocks.file_source(
gr.sizeof_float * 1, "../misc/data/file_reader_test_1M", False)
elif args.fake_data == '2':
self.reader = blocks.file_source(
gr.sizeof_float * 1, "../misc/data/file_reader_test_2M", False)
elif args.fake_data == False:
self.reader = rfid.reader(int(self.adc_rate / self.decim),
int(self.dac_rate))
else:
print(
"Fake data parameter not specified correctly. Transmitting real data."
)
self.reader = rfid.reader(int(self.adc_rate / self.decim),
int(self.dac_rate))
self.amp = blocks.multiply_const_ff(self.ampl)
self.to_complex = blocks.float_to_complex()
self.null_sink = blocks.null_sink(gr.sizeof_float * 1)
if args.cont_wave:
self.const_1 = analog.sig_source_c(0, analog.GR_CONST_WAVE, 0, 0,
.4)
elif args.delay_n:
self.delay = blocks.delay(gr.sizeof_gr_complex * 1, args.delay_n)
# Removed option for DEBUG. Not needed and convolutes the code.
# USRP blocks
self.u_source()
self.u_sink()
######## Connections #########
self.connect(self.source, self.low_pass)
self.connect(self.low_pass, self.gate)
self.connect(self.gate, self.tag_decoder)
if args.fake_data:
print("Args.fake_data is ", args.fake_data)
self.connect((self.tag_decoder, 0),
self.null_sink) #No longer need this data
else:
self.connect((self.tag_decoder, 0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, (self.sink, 0))
if args.cont_wave:
self.connect(self.const_1, (self.sink, 1))
elif args.delay_n:
self.connect(self.to_complex, self.delay)
self.connect(self.delay, (self.sink, 1))
elif args.single_tx:
pass
else:
self.connect(self.to_complex, (self.sink, 1))
#File sinks for logging (Remove comments to log data)
#self.connect(self.source, self.file_sink_source)
#File sinks for logging
self.connect(self.source, self.file_sink_source)
self.connect(self.gate, self.file_sink_gate)
self.connect((self.tag_decoder, 1),
self.file_sink_decoder) # (Do not comment this line)
self.connect(self.reader, self.file_sink_reader)
self.connect(self.low_pass, self.file_sink_matched_filter)
self.connect((self.to_complex), self.file_sink_sink)
def __init__(self):
gr.top_block.__init__(self)
#rt = gr.enable_realtime_scheduling()
######## Variables #########
self.dac_rate = 1e6 # DAC rate
self.adc_rate = 100e6/50 # ADC rate (2MS/s complex samples)
self.decim = 5 # Decimation (downsampling factor)
self.ampl = 0.1 # Output signal amplitude (signal power vary for different RFX900 cards)
self.freq = 910e6 # Modulation frequency (can be set between 902-920)
self.rx_gain = 20 # RX Gain (gain at receiver)
self.tx_gain = 20 # RFX900 no Tx gain option
self.usrp_address_source = "addr=192.168.10.2,recv_frame_size=256"
self.usrp_address_sink = "addr=192.168.10.2,recv_frame_size=256"
# Each FM0 symbol consists of ADC_RATE/BLF samples (2e6/40e3 = 50 samples)
# 10 samples per symbol after matched filtering and decimation
self.num_taps = [1] * 25 # matched to half symbol period
######## File sinks for debugging (1 for each block) #########
self.file_sink_source = blocks.file_sink(gr.sizeof_gr_complex*1, "../misc/data/source", False)
self.file_sink_matched_filter = blocks.file_sink(gr.sizeof_gr_complex*1, "../misc/data/matched_filter", False)
self.file_sink_gate = blocks.file_sink(gr.sizeof_gr_complex*1, "../misc/data/gate", False)
self.file_sink_decoder = blocks.file_sink(gr.sizeof_gr_complex*1, "../misc/data/decoder", False)
self.file_sink_reader = blocks.file_sink(gr.sizeof_float*1, "../misc/data/reader", False)
######## Blocks #########
self.matched_filter = filter.fir_filter_ccc(self.decim, self.num_taps);
self.gate = rfid.gate(int(self.adc_rate/self.decim))
self.tag_decoder = rfid.tag_decoder(int(self.adc_rate/self.decim))
self.reader = rfid.reader(int(self.adc_rate/self.decim),int(self.dac_rate))
self.amp = blocks.multiply_const_ff(self.ampl)
self.to_complex = blocks.float_to_complex()
if (DEBUG == False) : # Real Time Execution
# USRP blocks
self.u_source()
self.u_sink()
######## Connections #########
self.connect(self.source, self.matched_filter)
self.connect(self.matched_filter, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder,0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, self.sink)
#File sinks for logging (Remove comments to log data)
#self.connect(self.source, self.file_sink_source)
else : # Offline Data
self.file_source = blocks.file_source(gr.sizeof_gr_complex*1, "../misc/data/source_two_tag",False) ## instead of uhd.usrp_source
self.file_sink = blocks.file_sink(gr.sizeof_gr_complex*1, "../misc/data/reader_two_tag", False) ## instead of uhd.usrp_sink
######## Connections #########
self.connect(self.file_source, self.matched_filter)
self.connect(self.matched_filter, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder,0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, self.file_sink)
#File sinks for logging
#self.connect(self.gate, self.file_sink_gate)
self.connect((self.tag_decoder,1), self.file_sink_decoder) # (Do not comment this line)
def __init__(self):
gr.top_block.__init__(self, "Tifi")
Qt.QWidget.__init__(self)
self.setWindowTitle("Tifi")
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", "tifi")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = int(2e6)
self.dac_rate = dac_rate = int(1e6)
##################################################
# Blocks
##################################################
self.uhd_usrp_source_rfid = uhd.usrp_source(
",".join(("192.168.20.10", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_rfid.set_samp_rate(samp_rate)
self.uhd_usrp_source_rfid.set_center_freq(920e6, 0)
self.uhd_usrp_source_rfid.set_gain(0, 0)
self.uhd_usrp_source_rfid.set_antenna('RX2', 0)
self.uhd_usrp_sink_rfid = uhd.usrp_sink(
",".join(("192.168.20.10", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_rfid.set_samp_rate(dac_rate)
self.uhd_usrp_sink_rfid.set_center_freq(920e6, 0)
self.uhd_usrp_sink_rfid.set_gain(0, 0)
self.uhd_usrp_sink_rfid.set_antenna('TX/RX', 0)
self.uhd_usrp_sink_0 = uhd.usrp_sink(
",".join(("192.168.20.5", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0.set_center_freq(804e6, 0)
self.uhd_usrp_sink_0.set_gain(0, 0)
self.sendfile_sendfile_wifi_0 = sendfile.sendfile_wifi(
gr.sizeof_gr_complex)
self.rfid_tag_decoder_0 = rfid.tag_decoder(samp_rate)
self.rfid_reader_0 = rfid.reader(int(samp_rate), int(dac_rate))
self.rfid_gate_0 = rfid.gate(samp_rate)
self.interp_fir_filter_xxx_0 = filter.interp_fir_filter_ccc(5, (25, ))
self.interp_fir_filter_xxx_0.declare_sample_delay(0)
self.blocks_multiply_xx_0 = blocks.multiply_vff(1)
self.blocks_float_to_complex_0 = blocks.float_to_complex(1)
self.analog_const_source_x_0_0 = analog.sig_source_f(
0, analog.GR_CONST_WAVE, 0, 0, 0)
self.analog_const_source_x_0 = analog.sig_source_f(
0, analog.GR_CONST_WAVE, 0, 0, 0.1)
##################################################
# Connections
##################################################
self.connect((self.analog_const_source_x_0, 0),
(self.blocks_multiply_xx_0, 1))
self.connect((self.analog_const_source_x_0_0, 0),
(self.blocks_float_to_complex_0, 1))
self.connect((self.blocks_float_to_complex_0, 0),
(self.uhd_usrp_sink_rfid, 0))
self.connect((self.blocks_multiply_xx_0, 0),
(self.blocks_float_to_complex_0, 0))
self.connect((self.interp_fir_filter_xxx_0, 0), (self.rfid_gate_0, 0))
self.connect((self.rfid_gate_0, 0), (self.rfid_tag_decoder_0, 0))
self.connect((self.rfid_reader_0, 0), (self.blocks_multiply_xx_0, 0))
self.connect((self.rfid_tag_decoder_0, 0), (self.rfid_reader_0, 0))
self.connect((self.sendfile_sendfile_wifi_0, 0),
(self.uhd_usrp_sink_0, 0))
self.connect((self.uhd_usrp_source_rfid, 0),
(self.interp_fir_filter_xxx_0, 0))
def __init__(self):
gr.top_block.__init__(self)
rt = gr.enable_realtime_scheduling()
######## Variables #########
self.dac_rate = 2e6 # DAC rate
self.adc_rate = 0.8e6 # ADC rate (2MS/s complex samples)
self.decim = 2 # Decimation (downsampling factor)
self.ampl = 0.5 # Output signal amplitude (signal power vary for different RFX900 cards)
self.tx_freq_1 = 910e6 # Modulation frequency (can be set between 902-920)
self.tx_freq_2 = 910e6 # Modulation frequency (can be set between 902-920)
self.rx_gain = 20 # RX Gain (gain at receiver)
self.tx_gain_1 = int(sys.argv[1]) # RFX900 no Tx gain option
self.tx_gain_2 = int(sys.argv[2]) # RFX900 no Tx gain option
self.usrp_address_source = "addr0=192.168.10.2, addr1=192.168.20.2,recv_frame_size=256"
self.usrp_address_sink = "addr0=192.168.10.2, addr1=192.168.20.2,recv_frame_size=256"
# Each FM0 symbol consists of ADC_RATE/BLF samples (2e6/40e3 = 50 samples)
# 10 samples per symbol after matched filtering and decimation
self.num_taps = [1] * 2 * int(
self.adc_rate /
(2 * 2 * 40e3 * self.decim)) # matched to half symbol period
# Take half, round then double to ensure even number.
print("Half symbol length is ",
2 * int(self.adc_rate / (2 * 2 * 40e3 * self.decim)))
######## File sinks for debugging (1 for each block) #########
self.file_sink_source = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/source", False)
self.file_sink_matched_filter = blocks.file_sink(
gr.sizeof_gr_complex * 1, "../misc/data/matched_filter", False)
self.file_sink_gate = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/gate", False)
self.file_sink_decoder = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/decoder",
False)
self.file_sink_reader = blocks.file_sink(gr.sizeof_float * 1,
"../misc/data/reader", False)
self.file_sink_sink = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/sink", False)
######## Blocks #########
self.low_pass = filter.fir_filter_ccc(self.decim, self.num_taps)
#self.low_pass = filter.fir_filter_ccf(5, firdes.low_pass(1, self.adc_rate, 50000, 50000, firdes.WIN_HAMMING, 6.76))
self.gate = rfid.gate(int(self.adc_rate / self.decim))
self.tag_decoder = rfid.tag_decoder(int(self.adc_rate / self.decim))
self.reader = rfid.reader(int(self.adc_rate / self.decim),
int(self.dac_rate))
self.amp = blocks.multiply_const_ff(self.ampl)
self.to_complex = blocks.float_to_complex()
#self.delay = blocks.delay(gr.sizeof_gr_complex*1, 0)
if (DEBUG == False): # Real Time Execution
# USRP blocks
self.u_source()
self.u_sink()
######## Connections #########
self.connect(self.source, self.low_pass)
self.connect(self.low_pass, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder, 0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, (self.sink, 0))
#self.connect(self.to_complex, self.delay)
#self.connect(self.delay, (self.sink,1))
self.connect(self.to_complex, (self.sink, 1))
#File sinks for logging (Remove comments to log data)
#self.connect(self.source, self.file_sink_source)
else: # Offline Data
self.file_source = blocks.file_source(
gr.sizeof_gr_complex * 1, "../misc/data/file_source_test",
False) ## instead of uhd.usrp_source
self.file_sink = blocks.file_sink(
gr.sizeof_gr_complex * 1, "../misc/data/file_sink",
False) ## instead of uhd.usrp_sink
######## Connections #########
self.connect(self.file_source, self.matched_filter)
self.connect(self.matched_filter, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder, 0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, self.file_sink)
#File sinks for logging
self.connect(self.source, self.file_sink_source)
self.connect(self.gate, self.file_sink_gate)
self.connect((self.tag_decoder, 1),
self.file_sink_decoder) # (Do not comment this line)
self.connect(self.reader, self.file_sink_reader)
self.connect(self.low_pass, self.file_sink_matched_filter)
self.connect((self.to_complex), self.file_sink_sink)
def __init__(self):
gr.top_block.__init__(self)
rt = gr.enable_realtime_scheduling()
######## Variables #########
self.dac_rate = 3.35 * 1e6 # DAC rate
self.adc_rate = 3.35 * 100e6 / 50 # ADC rate
#self.dac_rate = 1e6 # DAC rate
#self.adc_rate = 100e6/50 # ADC rate
self.decim = 5 # Decimation (downsampling factor)
self.ampl = 0.6 # Output signal amplitude (signal power vary for different RFX900 cards)
self.freq = 910e6 # Modulation frequency (can be set between 902-920)
self.rx_gain = 30 # RX Gain - this is automatically spread out between TIA, PGA, and LNA
self.tx_gain = 60
# Each FM0 symbol consists of ADC_RATE/BLF samples (6.7e6/40e3 = 83.75 samples)
self.num_taps = [1] * 83 # matched to half symbol period
######## File sinks for debugging (1 for each block) #########
self.file_sink_source = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/source", False)
self.file_sink_matched_filter = blocks.file_sink(
gr.sizeof_gr_complex * 1, "../misc/data/matched_filter", False)
self.file_sink_gate = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/gate", False)
self.file_sink_decoder = blocks.file_sink(gr.sizeof_gr_complex * 1,
"../misc/data/decoder",
False)
self.file_sink_reader = blocks.file_sink(gr.sizeof_float * 1,
"../misc/data/reader", False)
self.file_sink_to_complex = blocks.file_sink(
gr.sizeof_gr_complex * 1, "../misc/data/to_complex", False)
######## Blocks #########
self.matched_filter = filter.fir_filter_ccf(self.decim, self.num_taps)
self.gate = rfid.gate(int(self.adc_rate / self.decim))
self.tag_decoder = rfid.tag_decoder(int(self.adc_rate / self.decim))
self.reader = rfid.reader(int(self.adc_rate / self.decim),
int(self.dac_rate))
self.amp = blocks.multiply_const_ff(self.ampl)
self.to_complex = blocks.float_to_complex(1)
# Source/sink blocks
self.u_source = uhd.usrp_source(
",".join(("", "driver=lime,soapy=0")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.u_sink = uhd.usrp_sink(
",".join(("", "driver=lime,soapy=0")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.u_source.set_samp_rate(self.adc_rate)
self.u_source.set_center_freq(self.freq, 0)
self.u_source.set_gain(self.rx_gain, 0) #spread between TIA, PGA, LNA
self.u_source.set_antenna("LNAL", 0)
self.u_sink.set_samp_rate(self.dac_rate)
self.u_sink.set_center_freq(self.freq, 0)
self.u_sink.set_gain(self.tx_gain,
0) #I think this does nothing, not sure though
self.u_sink.set_antenna("BAND1", 0)
######## Connections #########
if (OFFLINE == False): # Real Time Execution
######## Connections #########
self.connect(self.u_source, self.matched_filter)
self.connect(self.matched_filter, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder, 0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, self.u_sink)
self.connect(self.u_source, self.file_sink_source)
else: # Offline Data
self.file_source = blocks.file_source(
gr.sizeof_gr_complex * 1, "../misc/data/file_source_test",
False) ## instead of uhd.usrp_source
self.file_sink = blocks.file_sink(
gr.sizeof_gr_complex * 1, "../misc/data/file_sink",
False) ## instead of uhd.usrp_sink
######## Connections #########
self.connect(self.file_source, self.matched_filter)
self.connect(self.matched_filter, self.gate)
self.connect(self.gate, self.tag_decoder)
self.connect((self.tag_decoder, 0), self.reader)
self.connect(self.reader, self.amp)
self.connect(self.amp, self.to_complex)
self.connect(self.to_complex, self.file_sink)
#File sinks for logging
self.connect(self.gate, self.file_sink_gate)
self.connect((self.tag_decoder, 1),
self.file_sink_decoder) # (Do not comment this line)
self.connect(self.reader, self.file_sink_reader)
self.connect(self.matched_filter, self.file_sink_matched_filter)
