def __init__(self):
gr.basic_block.__init__(
self,
name="fftprocess",
in_sig=[(numpy.float32, my_consts.fft_size())],
out_sig=[(numpy.float32, my_consts.agg_out())],
)
#set vars / consts
self.hold_times = my_consts.hold_times()
self.hold_cnt = 0
self.start_time = time.time()
self.temp = 0
#vector in / out len
self.fft_size = my_consts.fft_size()
self.agg_out = my_consts.agg_out()
def __init__(self):
gr.basic_block.__init__(
self,
name="fftprocess",
in_sig=[(numpy.float32, my_consts.fft_size())],
out_sig=[(numpy.float32, my_consts.agg_out())],
)
#consts
self.hold_times = my_consts.hold_times()
self.fft_size = my_consts.fft_size()
self.agg_out = my_consts.agg_out()
self.start_time = time.time()
#mutable vars
self.hold_cnt = 0 #counts fft blocks processed so far (resets once reaches hold_times)
self.out_current = numpy.zeros(
(self.agg_out * my_consts.in_bins_per_out_bin(), ),
dtype=numpy.float32) #current block
def __init__(self):
gr.basic_block.__init__(self,
name="dumptofile",
in_sig=[(numpy.float32, my_consts.agg_out())],
out_sig=None)
#set consts, vars
self.aggregate_length = int(
(my_consts.samp_rate() / my_consts.fft_size()) /
(my_consts.hold_times() * my_consts.keep_1_fft_blk_per_n()) *
my_consts.time_length_per_file())
#print str(self.aggregate_length)
self.cnt = 0
self.opened_file_name = generatefilename()
self.opened_file = open(self.opened_file_name, 'wb')
if len(sys.argv) == 4:
mode = sys.argv[2]
val = sys.argv[3]
if len(sys.argv) == 5:
mode = sys.argv[2]
val_1 = sys.argv[3]
val_2 = sys.argv[4]
#get data, time
data = np.fromfile(path, dtype=np.float32)
timestamp = np.fromfile(path, dtype=np.float64)
#reshape, drop first 2 cols (which is actually timestamp)
data = data.reshape(
len(data) / (my_consts.agg_out() + 2), (my_consts.agg_out() + 2))
data = np.delete(data, 0, 1)
data = np.delete(data, 0, 1)
#drop data, and keep timestamp.
timestamp = timestamp.reshape(
len(timestamp) / ((my_consts.agg_out() + 2) / 2),
((my_consts.agg_out() + 2) / 2))
timestamp = timestamp[:, 0]
#Plot mode. (1D plot; at time t)
if mode == '-p':
val = int(val)
print timestamp[val]
plt.plot(data[val])
plt.show()
def __init__(self):
#init the top block and GUI.
gr.top_block.__init__(self, "Nist-v2")
Qt.QWidget.__init__(self)
self.setWindowTitle("Nist-v2")
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", "nist")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
#FFT Len, Calibration factor, Windowing function compensation.
self.fft_len = fft_len = my_consts.fft_size()
self.cal_dB = cal_dB = my_consts.cal_dB()
self.window_compenstation = window_compenstation = 2.0
#Target freq / sampling rate
self.target_freq = target_freq = my_consts.center_freq()
self.samp_rate = samp_rate = my_consts.samp_rate()
#PSD adjustment factor (calculated using above variables)
self.psd_normalization = psd_normalization = (
[(window_compenstation / fft_len)**2] * my_consts.agg_out()
) #(2.0/FFT_SIZE) ^2 (applied after fft -> mag^2 to save processing power)
#calibration (applies the calibration factor and undo the power increase due to the amplifier gain).
self.cal = cal = 10**((cal_dB - my_consts.usrp_gain()) / 20)
if (my_consts.source_type() == "OSMOCOM"):
self.cal = cal = 10**(
(cal_dB - my_consts.osmosdr_RF_gain() -
my_consts.osmosdr_IF_gain() - my_consts.osmosdr_BB_gain()) /
20)
self.new_bin_size = new_bin_size = my_consts.agg_out()
#for usrp
self.usrp_lo_offset = usrp_lo_offset = my_consts.usrp_lo_offset()
self.usrp_gain = usrp_gain = my_consts.usrp_gain()
#for osmosdr
self.osmosdr_RF_gain = osmosdr_RF_gain = my_consts.osmosdr_RF_gain()
self.osmosdr_IF_gain = osmosdr_IF_gain = my_consts.osmosdr_IF_gain()
self.osmosdr_BB_gain = osmosdr_BB_gain = my_consts.osmosdr_BB_gain()
##################################################
# Blocks
##################################################
#------------------------------signal source------------------------------
#dummy signal mode
if my_consts.source_type() == "CONST":
self.uhd_usrp_source_0 = analog.sig_source_c(
0, analog.GR_CONST_WAVE, 0, 0, 1)
#usrp mode
elif my_consts.source_type() == "USRP":
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(target_freq, usrp_lo_offset), 0)
self.uhd_usrp_source_0.set_gain(usrp_gain, 0)
self.uhd_usrp_source_0.set_antenna(my_consts.antenna_port(), 0)
#osmosdr mode
elif my_consts.source_type() == "OSMOCOM":
self.uhd_usrp_source_0 = osmosdr.source(args="numchan=" + str(1) +
" " + '')
self.uhd_usrp_source_0.set_sample_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(target_freq, 0)
self.uhd_usrp_source_0.set_freq_corr(0, 0)
self.uhd_usrp_source_0.set_dc_offset_mode(0, 0)
self.uhd_usrp_source_0.set_iq_balance_mode(0, 0)
self.uhd_usrp_source_0.set_gain_mode(False, 0)
self.uhd_usrp_source_0.set_gain(osmosdr_RF_gain, 0)
self.uhd_usrp_source_0.set_if_gain(osmosdr_IF_gain, 0)
self.uhd_usrp_source_0.set_bb_gain(osmosdr_BB_gain, 0)
self.uhd_usrp_source_0.set_antenna(my_consts.antenna_port(), 0)
self.uhd_usrp_source_0.set_bandwidth(samp_rate, 0)
#------------------------------signal source end--------------------------
#junks (removed QT gui)
self.qtgui_vector_sink_f_0 = qtgui.vector_sink_f(
new_bin_size,
0,
1.0,
"x-Axis",
"y-Axis",
"",
1 # Number of inputs
)
#self.qtgui_vector_sink_f_0.set_update_time(0.10)
#self.qtgui_vector_sink_f_0.set_y_axis(-140, 10)
#self.qtgui_vector_sink_f_0.enable_autoscale(False)
#self.qtgui_vector_sink_f_0.enable_grid(False)
#self.qtgui_vector_sink_f_0.set_x_axis_units("")
#self.qtgui_vector_sink_f_0.set_y_axis_units("")
#self.qtgui_vector_sink_f_0.set_ref_level(0)
#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 xrange(1):
# if len(labels[i]) == 0:
# self.qtgui_vector_sink_f_0.set_line_label(i, "Data {0}".format(i))
# else:
# self.qtgui_vector_sink_f_0.set_line_label(i, labels[i])
# self.qtgui_vector_sink_f_0.set_line_width(i, widths[i])
# self.qtgui_vector_sink_f_0.set_line_color(i, colors[i])
# self.qtgui_vector_sink_f_0.set_line_alpha(i, alphas[i])
#self._qtgui_vector_sink_f_0_win = sip.wrapinstance(self.qtgui_vector_sink_f_0.pyqwidget(), Qt.QWidget)
#self.top_layout.addWidget(self._qtgui_vector_sink_f_0_win)
#PSD Normalizer / FFT / log10 / data -> Mag^2 blocks
self.mul_const = blocks.multiply_const_vff((psd_normalization))
self.fft_vxx_0 = fft.fft_vcc(fft_len, True, (window.hann(fft_len)),
True, my_consts.fft_threads())
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(
gr.sizeof_gr_complex * 1, fft_len)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, new_bin_size, 0)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(
fft_len)
#if calibration needed: create cal block
if abs(cal) > 0.1:
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc(
(cal, ))
#my blocks (process/aggregrate FFT data / dump data to files)
self.fftprocess = fftprocess()
self.dumptofile = dumptofile()
#debug blocks (performance eval, etc)
if my_consts.debug_mode():
self.blocks_probe_rate_0 = blocks.probe_rate(
gr.sizeof_float * self.fft_len, 1000.0, 0.15)
self.blocks_message_debug_0 = blocks.message_debug()
#throws out n-1 snapshots and use only 1 for calculation
self.blocks_keep_one_in_n_0 = blocks.keep_one_in_n(
gr.sizeof_gr_complex * fft_len, my_consts.keep_1_fft_blk_per_n())
##################################################
# Connections
##################################################
if abs(cal) > 0.1: #if calibration needed:
# usrp -> calibration
self.connect((self.uhd_usrp_source_0, 0),
(self.blocks_multiply_const_vxx_0, 0))
#calibration -> vector
self.connect((self.blocks_multiply_const_vxx_0, 0),
(self.blocks_stream_to_vector_0, 0))
else: #if calibration not needed:
# usrp -> vector
self.connect((self.uhd_usrp_source_0, 0),
(self.blocks_stream_to_vector_0, 0))
#Throw out n-1 snapshots and keep 1
self.connect((self.blocks_stream_to_vector_0, 0),
(self.blocks_keep_one_in_n_0, 0))
#fft -> mag^2
self.connect((self.blocks_keep_one_in_n_0, 0), (self.fft_vxx_0, 0))
self.connect((self.fft_vxx_0, 0),
(self.blocks_complex_to_mag_squared_0, 0))
#re-bin fft, max-hold.
self.connect((self.blocks_complex_to_mag_squared_0, 0),
(self.fftprocess, 0))
#normalize by multiplying ((window compensation)/N)^2
self.connect((self.fftprocess, 0), (self.mul_const, 0))
#to log
self.connect((self.mul_const, 0), (self.blocks_nlog10_ff_0, 0))
#display (temporary)
#self.connect((self.blocks_nlog10_ff_0, 0), (self.qtgui_vector_sink_f_0, 0))
#data -> file
self.connect((self.blocks_nlog10_ff_0, 0), (self.dumptofile, 0))
#debug blocks
#performance eval
if my_consts.debug_mode():
self.connect((self.blocks_complex_to_mag_squared_0, 0),
(self.blocks_probe_rate_0, 0))
self.msg_connect((self.blocks_probe_rate_0, 'rate'),
(self.blocks_message_debug_0, 'print'))
def set_window_compenstation(self, window_compenstation):
self.window_compenstation = window_compenstation
self.set_psd_normalization([(window_compenstation / fft_len)**2] *
my_consts.agg_out())