#!/usr/bin/env python2 # -*- coding: utf-8 -*- ################################################## # GNU Radio Python Flow Graph # Title: Chirp Hopper # Generated: Fri Apr 27 12:37:29 2018 ################################################## if __name__ == '__main__': import ctypes import sys if sys.platform.startswith('linux'): try: x11 = ctypes.cdll.LoadLibrary('libX11.so') x11.XInitThreads() except: print "Warning: failed to XInitThreads()" from PyQt4 import Qt from gnuradio import analog from gnuradio import blocks from gnuradio import eng_notation from gnuradio import gr from gnuradio import gr, blocks from gnuradio import uhd from gnuradio.eng_option import eng_option from gnuradio.filter import firdes from optparse import OptionParser import numpy as np import sys import threading import time from gnuradio import qtgui class chirp_hopper(gr.top_block, Qt.QWidget): def __init__(self, center_freq_max=2.7e9, center_freq_min=2.2e9, chirpLen_s=100e-3, freq_step=40e6, period_s=.2, phase_rad=0, pre_gain=0.25, sps=64, start_Hz=1, stop_Hz=20e6, tx_gain=0): gr.top_block.__init__(self, "Chirp Hopper") Qt.QWidget.__init__(self) self.setWindowTitle("Chirp Hopper") 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", "chirp_hopper") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Parameters ################################################## self.center_freq_max = center_freq_max self.center_freq_min = center_freq_min self.chirpLen_s = chirpLen_s self.freq_step = freq_step self.period_s = period_s self.phase_rad = phase_rad self.pre_gain = pre_gain self.sps = sps self.start_Hz = start_Hz self.stop_Hz = stop_Hz self.tx_gain = tx_gain ################################################## # Variables ################################################## self.samp_rate = samp_rate = 40e6 self.numSamples = numSamples = samp_rate*chirpLen_s self.times_s = times_s = np.linspace(0,chirpLen_s,numSamples) self.k = k = (stop_Hz-start_Hz)/chirpLen_s self.sweepFreqs_Hz = sweepFreqs_Hz = (start_Hz+k/2.*times_s)*times_s self.func_center_freq = func_center_freq = [center_freq_min] self.lo_offset = lo_offset = -((samp_rate) * 1.25) self.chirp = chirp = np.sin(phase_rad +2*np.pi*sweepFreqs_Hz) self.Current_Center_Frequency = Current_Center_Frequency = int(func_center_freq[0]) ################################################## # Blocks ################################################## self.probe_center_freq = blocks.probe_signal_vf(1) def _func_center_freq_probe(): while True: val = self.probe_center_freq.level() try: self.set_func_center_freq(val) except AttributeError: pass time.sleep(1.0 / (5)) _func_center_freq_thread = threading.Thread(target=_func_center_freq_probe) _func_center_freq_thread.daemon = True _func_center_freq_thread.start() self.uhd_usrp_source_0 = uhd.usrp_source( ",".join(("addr=192.168.10.2", "")), 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(func_center_freq[0], 0) self.uhd_usrp_source_0.set_gain(tx_gain, 0) self.uhd_usrp_source_0.set_antenna('RX2', 0) self.uhd_usrp_sink_0 = uhd.usrp_sink( ",".join(("addr=192.168.10.2", "")), 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(func_center_freq[0], 0) self.uhd_usrp_sink_0.set_gain(tx_gain, 0) self.uhd_usrp_sink_0.set_antenna('TX/RX', 0) self.blocks_vector_source_x_0 = blocks.vector_source_c(np.hstack((chirp, np.zeros(int((period_s-chirpLen_s)*samp_rate)))), True, 1, []) self.blocks_multiply_const_vxx_0_0 = blocks.multiply_const_vff((0, )) self.blocks_file_meta_sink_2 = blocks.file_meta_sink(gr.sizeof_gr_complex*1, '/home/laura.huddleston/Documents/GNURadioCompanion/data/freq_hop_data.dat', samp_rate, 1, blocks.GR_FILE_FLOAT, True, 1000000, "", False) self.blocks_file_meta_sink_2.set_unbuffered(False) self.blocks_file_meta_sink_1 = blocks.file_meta_sink(gr.sizeof_gr_complex*1, '/home/laura.huddleston/Documents/GNURadioCompanion/data/output_data.dat', samp_rate, 1, blocks.GR_FILE_FLOAT, True, 1000000, "", False) self.blocks_file_meta_sink_1.set_unbuffered(False) self.blocks_file_meta_sink_0 = blocks.file_meta_sink(gr.sizeof_gr_complex*1, '/home/laura.huddleston/Documents/GNURadioCompanion/data/input_data.dat', samp_rate, 1, blocks.GR_FILE_FLOAT, True, 1000000, "", False) self.blocks_file_meta_sink_0.set_unbuffered(False) self.blocks_complex_to_float_0 = blocks.complex_to_float(1) self.blocks_add_xx_0 = blocks.add_vff(1) self.analog_const_source_x_0_0 = analog.sig_source_f(0, analog.GR_CONST_WAVE, 0, 0, center_freq_min if ((func_center_freq[0] > center_freq_max) or (func_center_freq[0] < center_freq_min)) else (func_center_freq[0] + freq_step)) self.analog_const_source_x_0 = analog.sig_source_c(0, analog.GR_CONST_WAVE, 0, 0, func_center_freq[0]) self._Current_Center_Frequency_tool_bar = Qt.QToolBar(self) if None: self._Current_Center_Frequency_formatter = None else: self._Current_Center_Frequency_formatter = lambda x: str(x) self._Current_Center_Frequency_tool_bar.addWidget(Qt.QLabel("Current_Center_Frequency"+": ")) self._Current_Center_Frequency_label = Qt.QLabel(str(self._Current_Center_Frequency_formatter(self.Current_Center_Frequency))) self._Current_Center_Frequency_tool_bar.addWidget(self._Current_Center_Frequency_label) self.top_layout.addWidget(self._Current_Center_Frequency_tool_bar) ################################################## # Connections ################################################## self.connect((self.analog_const_source_x_0, 0), (self.blocks_file_meta_sink_2, 0)) self.connect((self.analog_const_source_x_0_0, 0), (self.blocks_add_xx_0, 1)) self.connect((self.blocks_add_xx_0, 0), (self.probe_center_freq, 0)) self.connect((self.blocks_complex_to_float_0, 0), (self.blocks_multiply_const_vxx_0_0, 0)) self.connect((self.blocks_multiply_const_vxx_0_0, 0), (self.blocks_add_xx_0, 0)) self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_complex_to_float_0, 0)) self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_file_meta_sink_0, 0)) self.connect((self.blocks_vector_source_x_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.blocks_file_meta_sink_1, 0)) def closeEvent(self, event): self.settings = Qt.QSettings("GNU Radio", "chirp_hopper") self.settings.setValue("geometry", self.saveGeometry()) event.accept() def get_center_freq_max(self): return self.center_freq_max def set_center_freq_max(self, center_freq_max): self.center_freq_max = center_freq_max self.analog_const_source_x_0_0.set_offset(self.center_freq_min if ((self.func_center_freq[0] > self.center_freq_max) or (self.func_center_freq[0] < self.center_freq_min)) else (self.func_center_freq[0] + self.freq_step)) def get_center_freq_min(self): return self.center_freq_min def set_center_freq_min(self, center_freq_min): self.center_freq_min = center_freq_min self.set_func_center_freq([self.center_freq_min]) self.analog_const_source_x_0_0.set_offset(self.center_freq_min if ((self.func_center_freq[0] > self.center_freq_max) or (self.func_center_freq[0] < self.center_freq_min)) else (self.func_center_freq[0] + self.freq_step)) def get_chirpLen_s(self): return self.chirpLen_s def set_chirpLen_s(self, chirpLen_s): self.chirpLen_s = chirpLen_s self.set_times_s(np.linspace(0,self.chirpLen_s,self.numSamples)) self.set_numSamples(self.samp_rate*self.chirpLen_s) self.set_k((self.stop_Hz-self.start_Hz)/self.chirpLen_s) self.blocks_vector_source_x_0.set_data(np.hstack((self.chirp, np.zeros(int((self.period_s-self.chirpLen_s)*self.samp_rate)))), []) def get_freq_step(self): return self.freq_step def set_freq_step(self, freq_step): self.freq_step = freq_step self.analog_const_source_x_0_0.set_offset(self.center_freq_min if ((self.func_center_freq[0] > self.center_freq_max) or (self.func_center_freq[0] < self.center_freq_min)) else (self.func_center_freq[0] + self.freq_step)) def get_period_s(self): return self.period_s def set_period_s(self, period_s): self.period_s = period_s self.blocks_vector_source_x_0.set_data(np.hstack((self.chirp, np.zeros(int((self.period_s-self.chirpLen_s)*self.samp_rate)))), []) def get_phase_rad(self): return self.phase_rad def set_phase_rad(self, phase_rad): self.phase_rad = phase_rad self.set_chirp(np.sin(self.phase_rad +2*np.pi*self.sweepFreqs_Hz)) def get_pre_gain(self): return self.pre_gain def set_pre_gain(self, pre_gain): self.pre_gain = pre_gain def get_sps(self): return self.sps def set_sps(self, sps): self.sps = sps def get_start_Hz(self): return self.start_Hz def set_start_Hz(self, start_Hz): self.start_Hz = start_Hz self.set_sweepFreqs_Hz((self.start_Hz+self.k/2.*self.times_s)*self.times_s) self.set_k((self.stop_Hz-self.start_Hz)/self.chirpLen_s) def get_stop_Hz(self): return self.stop_Hz def set_stop_Hz(self, stop_Hz): self.stop_Hz = stop_Hz self.set_k((self.stop_Hz-self.start_Hz)/self.chirpLen_s) def get_tx_gain(self): return self.tx_gain def set_tx_gain(self, tx_gain): self.tx_gain = tx_gain self.uhd_usrp_source_0.set_gain(self.tx_gain, 0) self.uhd_usrp_sink_0.set_gain(self.tx_gain, 0) def get_samp_rate(self): return self.samp_rate def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate self.uhd_usrp_source_0.set_samp_rate(self.samp_rate) self.uhd_usrp_sink_0.set_samp_rate(self.samp_rate) self.set_numSamples(self.samp_rate*self.chirpLen_s) self.set_lo_offset(-((self.samp_rate) * 1.25)) self.blocks_vector_source_x_0.set_data(np.hstack((self.chirp, np.zeros(int((self.period_s-self.chirpLen_s)*self.samp_rate)))), []) def get_numSamples(self): return self.numSamples def set_numSamples(self, numSamples): self.numSamples = numSamples self.set_times_s(np.linspace(0,self.chirpLen_s,self.numSamples)) def get_times_s(self): return self.times_s def set_times_s(self, times_s): self.times_s = times_s self.set_sweepFreqs_Hz((self.start_Hz+self.k/2.*self.times_s)*self.times_s) def get_k(self): return self.k def set_k(self, k): self.k = k self.set_sweepFreqs_Hz((self.start_Hz+self.k/2.*self.times_s)*self.times_s) def get_sweepFreqs_Hz(self): return self.sweepFreqs_Hz def set_sweepFreqs_Hz(self, sweepFreqs_Hz): self.sweepFreqs_Hz = sweepFreqs_Hz self.set_chirp(np.sin(self.phase_rad +2*np.pi*self.sweepFreqs_Hz)) def get_func_center_freq(self): return self.func_center_freq def set_func_center_freq(self, func_center_freq): self.func_center_freq = func_center_freq self.uhd_usrp_source_0.set_center_freq(self.func_center_freq[0], 0) self.uhd_usrp_sink_0.set_center_freq(self.func_center_freq[0], 0) self.analog_const_source_x_0_0.set_offset(self.center_freq_min if ((self.func_center_freq[0] > self.center_freq_max) or (self.func_center_freq[0] < self.center_freq_min)) else (self.func_center_freq[0] + self.freq_step)) self.analog_const_source_x_0.set_offset(self.func_center_freq[0]) self.set_Current_Center_Frequency(self._Current_Center_Frequency_formatter(int(self.func_center_freq[0]))) def get_lo_offset(self): return self.lo_offset def set_lo_offset(self, lo_offset): self.lo_offset = lo_offset def get_chirp(self): return self.chirp def set_chirp(self, chirp): self.chirp = chirp self.blocks_vector_source_x_0.set_data(np.hstack((self.chirp, np.zeros(int((self.period_s-self.chirpLen_s)*self.samp_rate)))), []) def get_Current_Center_Frequency(self): return self.Current_Center_Frequency def set_Current_Center_Frequency(self, Current_Center_Frequency): self.Current_Center_Frequency = Current_Center_Frequency Qt.QMetaObject.invokeMethod(self._Current_Center_Frequency_label, "setText", Qt.Q_ARG("QString", self.Current_Center_Frequency)) def argument_parser(): parser = OptionParser(usage="%prog: [options]", option_class=eng_option) parser.add_option( "-m", "--center-freq-max", dest="center_freq_max", type="eng_float", default=eng_notation.num_to_str(2.7e9), help="Set center_freq_max [default=%default]") parser.add_option( "-f", "--center-freq-min", dest="center_freq_min", type="eng_float", default=eng_notation.num_to_str(2.2e9), help="Set center_freq_min [default=%default]") parser.add_option( "", "--chirpLen-s", dest="chirpLen_s", type="eng_float", default=eng_notation.num_to_str(100e-3), help="Set chirpLen_s [default=%default]") parser.add_option( "-e", "--freq-step", dest="freq_step", type="eng_float", default=eng_notation.num_to_str(40e6), help="Set freq_step [default=%default]") parser.add_option( "", "--period-s", dest="period_s", type="eng_float", default=eng_notation.num_to_str(.2), help="Set period_s [default=%default]") parser.add_option( "", "--phase-rad", dest="phase_rad", type="intx", default=0, help="Set phase_rad [default=%default]") parser.add_option( "-p", "--pre-gain", dest="pre_gain", type="eng_float", default=eng_notation.num_to_str(0.25), help="Set pre_gain [default=%default]") parser.add_option( "-y", "--sps", dest="sps", type="intx", default=64, help="Set samples per symbol [default=%default]") parser.add_option( "", "--start-Hz", dest="start_Hz", type="eng_float", default=eng_notation.num_to_str(1), help="Set start_Hz [default=%default]") parser.add_option( "", "--stop-Hz", dest="stop_Hz", type="eng_float", default=eng_notation.num_to_str(20e6), help="Set stop_Hz [default=%default]") parser.add_option( "-t", "--tx-gain", dest="tx_gain", type="eng_float", default=eng_notation.num_to_str(0), help="Set tx_gain [default=%default]") return parser def main(top_block_cls=chirp_hopper, options=None): if options is None: options, _ = argument_parser().parse_args() from distutils.version import StrictVersion if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"): style = gr.prefs().get_string('qtgui', 'style', 'raster') Qt.QApplication.setGraphicsSystem(style) qapp = Qt.QApplication(sys.argv) tb = top_block_cls(center_freq_max=options.center_freq_max, center_freq_min=options.center_freq_min, chirpLen_s=options.chirpLen_s, freq_step=options.freq_step, period_s=options.period_s, phase_rad=options.phase_rad, pre_gain=options.pre_gain, sps=options.sps, start_Hz=options.start_Hz, stop_Hz=options.stop_Hz, tx_gain=options.tx_gain) tb.start() tb.show() def quitting(): tb.stop() tb.wait() qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting) qapp.exec_() if __name__ == '__main__': main()