def __init__(self): gr.top_block.__init__(self) Rs = 8000 f1 = 100 f2 = 200 npts = 2048 self.qapp = QtWidgets.QApplication(sys.argv) ss = open(gr.prefix() + '/share/gnuradio/themes/dark.qss') sstext = ss.read() ss.close() self.qapp.setStyleSheet(sstext) src1 = analog.sig_source_c(Rs, analog.GR_SIN_WAVE, f1, 0.1, 0) src2 = analog.sig_source_c(Rs, analog.GR_SIN_WAVE, f2, 0.1, 0) src = blocks.add_cc() channel = channels.channel_model(0.01) thr = blocks.throttle(gr.sizeof_gr_complex, 100*npts) self.snk1 = qtgui.time_sink_c(npts, Rs, "Complex Time Example", 1) self.connect(src1, (src,0)) self.connect(src2, (src,1)) self.connect(src, channel, thr, (self.snk1, 0)) #self.connect(src1, (self.snk1, 1)) #self.connect(src2, (self.snk1, 2)) self.ctrl_win = control_box() self.ctrl_win.attach_signal1(src1) self.ctrl_win.attach_signal2(src2) # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt5.QtWidgets.QWidget pyWin = sip.wrapinstance(pyQt, QtWidgets.QWidget) # Example of using signal/slot to set the title of a curve # FIXME: update for Qt5 #pyWin.setLineLabel.connect(pyWin.setLineLabel) #pyWin.emit(QtCore.SIGNAL("setLineLabel(int, QString)"), 0, "Re{sum}") self.snk1.set_line_label(0, "Re{Sum}") self.snk1.set_line_label(1, "Im{Sum}") #self.snk1.set_line_label(2, "Re{src1}") #self.snk1.set_line_label(3, "Im{src1}") #self.snk1.set_line_label(4, "Re{src2}") #self.snk1.set_line_label(5, "Im{src2}") # Can also set the color of a curve #self.snk1.set_color(5, "blue") self.snk1.set_update_time(0.5) #pyWin.show() self.main_box = dialog_box(pyWin, self.ctrl_win) self.main_box.show()
def __init__(self): gr.top_block.__init__(self) Rs = 8000 f1 = 100 f2 = 2000 npts = 2048 taps = filter.firdes.complex_band_pass_2(1, Rs, 1500, 2500, 100, 60) self.qapp = QtGui.QApplication(sys.argv) ss = open(gr.prefix() + '/share/gnuradio/themes/dark.qss') sstext = ss.read() ss.close() self.qapp.setStyleSheet(sstext) src1 = analog.sig_source_c(Rs, analog.GR_SIN_WAVE, f1, 0.1, 0) src2 = analog.sig_source_c(Rs, analog.GR_SIN_WAVE, f2, 0.1, 0) src = blocks.add_cc() channel = channels.channel_model(0.01) thr = blocks.throttle(gr.sizeof_gr_complex, 100*npts) filt = filter.fft_filter_ccc(1, taps) self.snk1 = qtgui.waterfall_sink_c(npts, filter.firdes.WIN_BLACKMAN_hARRIS, 0, Rs, "Complex Waterfall Example", 2) self.connect(src1, (src,0)) self.connect(src2, (src,1)) self.connect(src, channel, thr, (self.snk1, 0)) self.connect(thr, filt, (self.snk1, 1)) self.ctrl_win = control_box() self.ctrl_win.attach_signal1(src1) self.ctrl_win.attach_signal2(src2) # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) #pyWin.show() self.main_box = dialog_box(pyWin, self.ctrl_win) self.main_box.show()
def main(): from gnuradio import gr parser = argparse.ArgumentParser( description=VERSION_AND_DISCLAIMER_TEMPLATE % gr.version()) parser.add_argument('flow_graphs', nargs='*') parser.add_argument('--log', choices=['debug', 'info', 'warning', 'error', 'critical'], default='warning') args = parser.parse_args() # Enable logging # Note: All other modules need to use the 'grc.<module>' convention log = logging.getLogger('grc') log.setLevel(logging.DEBUG) # Console formatting console = logging.StreamHandler() console.setLevel(LOG_LEVELS[args.log]) #msg_format = '[%(asctime)s - %(levelname)8s] --- %(message)s (%(filename)s:%(lineno)s)' msg_format = '[%(levelname)s] %(message)s (%(filename)s:%(lineno)s)' date_format = '%I:%M' formatter = logging.Formatter(msg_format, datefmt=date_format) #formatter = utils.log.ConsoleFormatter() console.setFormatter(formatter) log.addHandler(console) py_version = sys.version.split()[0] log.debug("Starting GNU Radio Companion ({})".format(py_version)) # Delay importing until the logging is setup from .gui.Platform import Platform from .gui.Application import Application log.debug("Loading platform") platform = Platform( version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()), prefs=gr.prefs(), install_prefix=gr.prefix() ) platform.build_library() log.debug("Loading application") app = Application(args.flow_graphs, platform) log.debug("Running") sys.exit(app.run())
def __init__(self): gr.top_block.__init__(self) Rs = 100000 npts = 2048 #taps = filter.firdes.complex_band_pass_2(1, Rs, 1500, 2500, 100, 60) self.qapp = QtGui.QApplication(sys.argv) ss = open(gr.prefix() + '/share/gnuradio/themes/dark.qss') sstext = ss.read() ss.close() self.qapp.setStyleSheet(sstext) channel = channels.channel_model(0.01) thr = blocks.throttle(gr.sizeof_gr_complex, 100*npts) #filt = filter.fft_filter_ccc(1, taps) self.snk1 = qtgui.waterfall_sink_c(npts, filter.firdes.WIN_BLACKMAN_hARRIS, 0, Rs, "Waterfall monitor", 2) float_to_complex = blocks.float_to_complex() input_rate = 96000 #audio_input = "hw:Loopback,0,0" audio_input = "hw:PCH,0,0" src_audio = audio.source (input_rate, audio_input) self.connect((src_audio, 1), (float_to_complex, 0)) self.connect((src_audio, 0), (float_to_complex, 1)) self.connect(float_to_complex, channel, thr, (self.snk1, 0)) #self.connect(thr, filt, (self.snk1, 1)) self.connect(thr, (self.snk1, 1)) self.ctrl_win = control_box() # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) self.main_box = dialog_box(pyWin, self.ctrl_win) self.main_box.show()
def __init__(self): gr.top_block.__init__(self) self.qapp = QtGui.QApplication(sys.argv) # Set Parameters self.shift_fft = True self.decimation = 1 self.decimation_step = 50 self.center_f = 102 self.estimator = "Welch" self.src_type = "File" self.scale = "Logarithmic" # File Source Parameters self.d_file_rec_samp_rate = 32e3 self.d_file_file_to_open = "%s/share/gr-specest/4cos.dat" % gr.prefix() self.d_file_samp_type = gr.sizeof_gr_complex # UHD Source Parameters self.d_uhd_samp_type = gr.sizeof_gr_complex self.d_uhd_gain = 30 self.d_uhd_ant = "Rx" self.d_uhd_subdev_spec = "B:0" self.d_uhd_board_num = 0 self.d_uhd_samp_rate = 0.5e6 self.main_box = SpecEstGUI(self) self.samp_rate = 0 self.fft_size = 512 self.est_input_block_len = 512 self.uhd_src_active = False self.head = None self.decimator = None self.body = None self.foot = None self.sink = None self.cpu_watcher = None self.main_box.show() for estimator_name in estimators: estimators[estimator_name].connect_fg(self) self.set_head() self.set_body() self.set_decimator()
def main(): parser = optparse.OptionParser( usage='usage: %prog [options] [saved flow graphs]', version=VERSION_AND_DISCLAIMER_TEMPLATE % gr.version()) options, args = parser.parse_args() try: gtk.window_set_default_icon(gtk.IconTheme().load_icon('gnuradio-grc', 256, 0)) except: pass platform = Platform( prefs_file=gr.prefs(), version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()), install_prefix=gr.prefix() ) ActionHandler(args, platform) gtk.main()
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA """ import os import sys import pygtk pygtk.require('2.0') import gtk from gnuradio import gr prefs = gr.prefs() GR_PREFIX = gr.prefix() EDITOR = prefs.get_string('grc', 'editor', '') # default path for the open/save dialogs DEFAULT_FILE_PATH = os.getcwd() # file extensions IMAGE_FILE_EXTENSION = '.png' TEXT_FILE_EXTENSION = '.txt' # name for new/unsaved flow graphs NEW_FLOGRAPH_TITLE = 'untitled' # main window constraints MIN_WINDOW_WIDTH = 600 MIN_WINDOW_HEIGHT = 400
def __init__(self): gr.top_block.__init__(self, "Ber Curve Gen Ldpc") Qt.QWidget.__init__(self) self.setWindowTitle("Ber Curve Gen Ldpc") 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", "ber_curve_gen_ldpc") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.framebits = framebits = 4096 self.esno_0 = esno_0 = numpy.arange(0, 8.1, .5) self.H = H = fec.ldpc_H_matrix( gr.prefix() + "/share/gnuradio/fec/ldpc/n_1800_k_0902_gap_28.alist", 28) self.G = G = fec.ldpc_G_matrix( gr.prefix() + "/share/gnuradio/fec/ldpc/simple_g_matrix.alist") self.samp_rate_0 = samp_rate_0 = 350000 self.k = k = 7 self.enc_rep = enc_rep = map((lambda b: map( (lambda a: fec.repetition_encoder_make(framebits, 3)), range(0, 1)) ), range(0, len(esno_0))) self.enc_ldpc_G = enc_ldpc_G = map((lambda b: map( (lambda a: fec.ldpc_gen_mtrx_encoder_make(G)), range(0, 1))), range(0, len(esno_0))) self.enc_ldpc = enc_ldpc = map((lambda b: map( (lambda a: fec.ldpc_par_mtrx_encoder_make_H(H)), range(0, 1))), range(0, len(esno_0))) self.enc_dummy = enc_dummy = map((lambda b: map( (lambda a: fec.dummy_encoder_make(framebits)), range(0, 1))), range(0, len(esno_0))) self.dec_rep = dec_rep = map((lambda b: map( (lambda a: fec.repetition_decoder.make(framebits, 3, 0.5)), range(0, 1))), range(0, len(esno_0))) self.dec_ldpc_G = dec_ldpc_G = map((lambda b: map( (lambda a: fec.ldpc_bit_flip_decoder.make(G.get_base_sptr(), 100)), range(0, 1))), range(0, len(esno_0))) self.dec_ldpc = dec_ldpc = map((lambda b: map( (lambda a: fec.ldpc_bit_flip_decoder.make(H.get_base_sptr(), 100)), range(0, 1))), range(0, len(esno_0))) self.dec_dummy = dec_dummy = map((lambda b: map( (lambda a: fec.dummy_decoder.make(framebits)), range(0, 1))), range(0, len(esno_0))) ################################################## # Blocks ################################################## self.qtgui_bercurve_sink_0 = qtgui.ber_sink_b( esno_0, #range of esnos 4, #number of curves 1000, #ensure at least -10, #cutoff [], #indiv. curve names ) self.qtgui_bercurve_sink_0.set_update_time(0.10) self.qtgui_bercurve_sink_0.set_y_axis(-10, 0) self.qtgui_bercurve_sink_0.set_x_axis(esno_0[0], esno_0[-1]) labels = [ 'None', 'Rep. (Rate=3)', 'LDPC (H matrix)', 'LDPC (Gen. matrix)', '', '', '', '', '', '' ] widths = [2, 2, 2, 2, 1, 1, 1, 1, 1, 1] colors = [ "black", "blue", "green", "red", "red", "red", "red", "red", "red", "red" ] styles = [3, 2, 4, 1, 0, 0, 0, 0, 0, 0] markers = [8, 1, 2, 0, 0, 0, 0, 0, 0, 0] alphas = [1, 1, 1, 1, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] for i in xrange(4): if len(labels[i]) == 0: self.qtgui_bercurve_sink_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_bercurve_sink_0.set_line_label(i, labels[i]) self.qtgui_bercurve_sink_0.set_line_width(i, widths[i]) self.qtgui_bercurve_sink_0.set_line_color(i, colors[i]) self.qtgui_bercurve_sink_0.set_line_style(i, styles[i]) self.qtgui_bercurve_sink_0.set_line_marker(i, markers[i]) self.qtgui_bercurve_sink_0.set_line_alpha(i, alphas[i]) self._qtgui_bercurve_sink_0_win = sip.wrapinstance( self.qtgui_bercurve_sink_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_bercurve_sink_0_win) self.fec_bercurve_generator_1 = fec.bercurve_generator( enc_ldpc, #size dec_ldpc, #name esno_0, #range of esnos samp_rate_0, #throttle "capillary", #threading mode '11', #puncture pattern -100 # noise gen. seed ) self.fec_bercurve_generator_0_0_0 = fec.bercurve_generator( enc_dummy, #size dec_dummy, #name esno_0, #range of esnos samp_rate_0, #throttle "capillary", #threading mode '11', #puncture pattern -100 # noise gen. seed ) self.fec_bercurve_generator_0_0 = fec.bercurve_generator( enc_rep, #size dec_rep, #name esno_0, #range of esnos samp_rate_0, #throttle "capillary", #threading mode '11', #puncture pattern -100 # noise gen. seed ) self.fec_bercurve_generator_0 = fec.bercurve_generator( enc_ldpc_G, #size dec_ldpc_G, #name esno_0, #range of esnos samp_rate_0, #throttle "capillary", #threading mode '11', #puncture pattern -100 # noise gen. seed ) ################################################## # Connections ################################################## self.connect((self.fec_bercurve_generator_0, 0), (self.qtgui_bercurve_sink_0, 102)) self.connect((self.fec_bercurve_generator_0, 1), (self.qtgui_bercurve_sink_0, 103)) self.connect((self.fec_bercurve_generator_0, 2), (self.qtgui_bercurve_sink_0, 104)) self.connect((self.fec_bercurve_generator_0, 3), (self.qtgui_bercurve_sink_0, 105)) self.connect((self.fec_bercurve_generator_0, 4), (self.qtgui_bercurve_sink_0, 106)) self.connect((self.fec_bercurve_generator_0, 5), (self.qtgui_bercurve_sink_0, 107)) self.connect((self.fec_bercurve_generator_0, 6), (self.qtgui_bercurve_sink_0, 108)) self.connect((self.fec_bercurve_generator_0, 7), (self.qtgui_bercurve_sink_0, 109)) self.connect((self.fec_bercurve_generator_0, 8), (self.qtgui_bercurve_sink_0, 110)) self.connect((self.fec_bercurve_generator_0, 9), (self.qtgui_bercurve_sink_0, 111)) self.connect((self.fec_bercurve_generator_0, 10), (self.qtgui_bercurve_sink_0, 112)) self.connect((self.fec_bercurve_generator_0, 11), (self.qtgui_bercurve_sink_0, 113)) self.connect((self.fec_bercurve_generator_0, 12), (self.qtgui_bercurve_sink_0, 114)) self.connect((self.fec_bercurve_generator_0, 13), (self.qtgui_bercurve_sink_0, 115)) self.connect((self.fec_bercurve_generator_0, 14), (self.qtgui_bercurve_sink_0, 116)) self.connect((self.fec_bercurve_generator_0, 15), (self.qtgui_bercurve_sink_0, 117)) self.connect((self.fec_bercurve_generator_0, 16), (self.qtgui_bercurve_sink_0, 118)) self.connect((self.fec_bercurve_generator_0, 17), (self.qtgui_bercurve_sink_0, 119)) self.connect((self.fec_bercurve_generator_0, 18), (self.qtgui_bercurve_sink_0, 120)) self.connect((self.fec_bercurve_generator_0, 19), (self.qtgui_bercurve_sink_0, 121)) self.connect((self.fec_bercurve_generator_0, 20), (self.qtgui_bercurve_sink_0, 122)) self.connect((self.fec_bercurve_generator_0, 21), (self.qtgui_bercurve_sink_0, 123)) self.connect((self.fec_bercurve_generator_0, 22), (self.qtgui_bercurve_sink_0, 124)) self.connect((self.fec_bercurve_generator_0, 23), (self.qtgui_bercurve_sink_0, 125)) self.connect((self.fec_bercurve_generator_0, 24), (self.qtgui_bercurve_sink_0, 126)) self.connect((self.fec_bercurve_generator_0, 25), (self.qtgui_bercurve_sink_0, 127)) self.connect((self.fec_bercurve_generator_0, 26), (self.qtgui_bercurve_sink_0, 128)) self.connect((self.fec_bercurve_generator_0, 27), (self.qtgui_bercurve_sink_0, 129)) self.connect((self.fec_bercurve_generator_0, 28), (self.qtgui_bercurve_sink_0, 130)) self.connect((self.fec_bercurve_generator_0, 29), (self.qtgui_bercurve_sink_0, 131)) self.connect((self.fec_bercurve_generator_0, 30), (self.qtgui_bercurve_sink_0, 132)) self.connect((self.fec_bercurve_generator_0, 31), (self.qtgui_bercurve_sink_0, 133)) self.connect((self.fec_bercurve_generator_0, 32), (self.qtgui_bercurve_sink_0, 134)) self.connect((self.fec_bercurve_generator_0, 33), (self.qtgui_bercurve_sink_0, 135)) self.connect((self.fec_bercurve_generator_0_0, 0), (self.qtgui_bercurve_sink_0, 34)) self.connect((self.fec_bercurve_generator_0_0, 1), (self.qtgui_bercurve_sink_0, 35)) self.connect((self.fec_bercurve_generator_0_0, 2), (self.qtgui_bercurve_sink_0, 36)) self.connect((self.fec_bercurve_generator_0_0, 3), (self.qtgui_bercurve_sink_0, 37)) self.connect((self.fec_bercurve_generator_0_0, 4), (self.qtgui_bercurve_sink_0, 38)) self.connect((self.fec_bercurve_generator_0_0, 5), (self.qtgui_bercurve_sink_0, 39)) self.connect((self.fec_bercurve_generator_0_0, 6), (self.qtgui_bercurve_sink_0, 40)) self.connect((self.fec_bercurve_generator_0_0, 7), (self.qtgui_bercurve_sink_0, 41)) self.connect((self.fec_bercurve_generator_0_0, 8), (self.qtgui_bercurve_sink_0, 42)) self.connect((self.fec_bercurve_generator_0_0, 9), (self.qtgui_bercurve_sink_0, 43)) self.connect((self.fec_bercurve_generator_0_0, 10), (self.qtgui_bercurve_sink_0, 44)) self.connect((self.fec_bercurve_generator_0_0, 11), (self.qtgui_bercurve_sink_0, 45)) self.connect((self.fec_bercurve_generator_0_0, 12), (self.qtgui_bercurve_sink_0, 46)) self.connect((self.fec_bercurve_generator_0_0, 13), (self.qtgui_bercurve_sink_0, 47)) self.connect((self.fec_bercurve_generator_0_0, 14), (self.qtgui_bercurve_sink_0, 48)) self.connect((self.fec_bercurve_generator_0_0, 15), (self.qtgui_bercurve_sink_0, 49)) self.connect((self.fec_bercurve_generator_0_0, 16), (self.qtgui_bercurve_sink_0, 50)) self.connect((self.fec_bercurve_generator_0_0, 17), (self.qtgui_bercurve_sink_0, 51)) self.connect((self.fec_bercurve_generator_0_0, 18), (self.qtgui_bercurve_sink_0, 52)) self.connect((self.fec_bercurve_generator_0_0, 19), (self.qtgui_bercurve_sink_0, 53)) self.connect((self.fec_bercurve_generator_0_0, 20), (self.qtgui_bercurve_sink_0, 54)) self.connect((self.fec_bercurve_generator_0_0, 21), (self.qtgui_bercurve_sink_0, 55)) self.connect((self.fec_bercurve_generator_0_0, 22), (self.qtgui_bercurve_sink_0, 56)) self.connect((self.fec_bercurve_generator_0_0, 23), (self.qtgui_bercurve_sink_0, 57)) self.connect((self.fec_bercurve_generator_0_0, 24), (self.qtgui_bercurve_sink_0, 58)) self.connect((self.fec_bercurve_generator_0_0, 25), (self.qtgui_bercurve_sink_0, 59)) self.connect((self.fec_bercurve_generator_0_0, 26), (self.qtgui_bercurve_sink_0, 60)) self.connect((self.fec_bercurve_generator_0_0, 27), (self.qtgui_bercurve_sink_0, 61)) self.connect((self.fec_bercurve_generator_0_0, 28), (self.qtgui_bercurve_sink_0, 62)) self.connect((self.fec_bercurve_generator_0_0, 29), (self.qtgui_bercurve_sink_0, 63)) self.connect((self.fec_bercurve_generator_0_0, 30), (self.qtgui_bercurve_sink_0, 64)) self.connect((self.fec_bercurve_generator_0_0, 31), (self.qtgui_bercurve_sink_0, 65)) self.connect((self.fec_bercurve_generator_0_0, 32), (self.qtgui_bercurve_sink_0, 66)) self.connect((self.fec_bercurve_generator_0_0, 33), (self.qtgui_bercurve_sink_0, 67)) self.connect((self.fec_bercurve_generator_0_0_0, 0), (self.qtgui_bercurve_sink_0, 0)) self.connect((self.fec_bercurve_generator_0_0_0, 1), (self.qtgui_bercurve_sink_0, 1)) self.connect((self.fec_bercurve_generator_0_0_0, 2), (self.qtgui_bercurve_sink_0, 2)) self.connect((self.fec_bercurve_generator_0_0_0, 3), (self.qtgui_bercurve_sink_0, 3)) self.connect((self.fec_bercurve_generator_0_0_0, 4), (self.qtgui_bercurve_sink_0, 4)) self.connect((self.fec_bercurve_generator_0_0_0, 5), (self.qtgui_bercurve_sink_0, 5)) self.connect((self.fec_bercurve_generator_0_0_0, 6), (self.qtgui_bercurve_sink_0, 6)) self.connect((self.fec_bercurve_generator_0_0_0, 7), (self.qtgui_bercurve_sink_0, 7)) self.connect((self.fec_bercurve_generator_0_0_0, 8), (self.qtgui_bercurve_sink_0, 8)) self.connect((self.fec_bercurve_generator_0_0_0, 9), (self.qtgui_bercurve_sink_0, 9)) self.connect((self.fec_bercurve_generator_0_0_0, 10), (self.qtgui_bercurve_sink_0, 10)) self.connect((self.fec_bercurve_generator_0_0_0, 11), (self.qtgui_bercurve_sink_0, 11)) self.connect((self.fec_bercurve_generator_0_0_0, 12), (self.qtgui_bercurve_sink_0, 12)) self.connect((self.fec_bercurve_generator_0_0_0, 13), (self.qtgui_bercurve_sink_0, 13)) self.connect((self.fec_bercurve_generator_0_0_0, 14), (self.qtgui_bercurve_sink_0, 14)) self.connect((self.fec_bercurve_generator_0_0_0, 15), (self.qtgui_bercurve_sink_0, 15)) self.connect((self.fec_bercurve_generator_0_0_0, 16), (self.qtgui_bercurve_sink_0, 16)) self.connect((self.fec_bercurve_generator_0_0_0, 17), (self.qtgui_bercurve_sink_0, 17)) self.connect((self.fec_bercurve_generator_0_0_0, 18), (self.qtgui_bercurve_sink_0, 18)) self.connect((self.fec_bercurve_generator_0_0_0, 19), (self.qtgui_bercurve_sink_0, 19)) self.connect((self.fec_bercurve_generator_0_0_0, 20), (self.qtgui_bercurve_sink_0, 20)) self.connect((self.fec_bercurve_generator_0_0_0, 21), (self.qtgui_bercurve_sink_0, 21)) self.connect((self.fec_bercurve_generator_0_0_0, 22), (self.qtgui_bercurve_sink_0, 22)) self.connect((self.fec_bercurve_generator_0_0_0, 23), (self.qtgui_bercurve_sink_0, 23)) self.connect((self.fec_bercurve_generator_0_0_0, 24), (self.qtgui_bercurve_sink_0, 24)) self.connect((self.fec_bercurve_generator_0_0_0, 25), (self.qtgui_bercurve_sink_0, 25)) self.connect((self.fec_bercurve_generator_0_0_0, 26), (self.qtgui_bercurve_sink_0, 26)) self.connect((self.fec_bercurve_generator_0_0_0, 27), (self.qtgui_bercurve_sink_0, 27)) self.connect((self.fec_bercurve_generator_0_0_0, 28), (self.qtgui_bercurve_sink_0, 28)) self.connect((self.fec_bercurve_generator_0_0_0, 29), (self.qtgui_bercurve_sink_0, 29)) self.connect((self.fec_bercurve_generator_0_0_0, 30), (self.qtgui_bercurve_sink_0, 30)) self.connect((self.fec_bercurve_generator_0_0_0, 31), (self.qtgui_bercurve_sink_0, 31)) self.connect((self.fec_bercurve_generator_0_0_0, 32), (self.qtgui_bercurve_sink_0, 32)) self.connect((self.fec_bercurve_generator_0_0_0, 33), (self.qtgui_bercurve_sink_0, 33)) self.connect((self.fec_bercurve_generator_1, 0), (self.qtgui_bercurve_sink_0, 68)) self.connect((self.fec_bercurve_generator_1, 1), (self.qtgui_bercurve_sink_0, 69)) self.connect((self.fec_bercurve_generator_1, 2), (self.qtgui_bercurve_sink_0, 70)) self.connect((self.fec_bercurve_generator_1, 3), (self.qtgui_bercurve_sink_0, 71)) self.connect((self.fec_bercurve_generator_1, 4), (self.qtgui_bercurve_sink_0, 72)) self.connect((self.fec_bercurve_generator_1, 5), (self.qtgui_bercurve_sink_0, 73)) self.connect((self.fec_bercurve_generator_1, 6), (self.qtgui_bercurve_sink_0, 74)) self.connect((self.fec_bercurve_generator_1, 7), (self.qtgui_bercurve_sink_0, 75)) self.connect((self.fec_bercurve_generator_1, 8), (self.qtgui_bercurve_sink_0, 76)) self.connect((self.fec_bercurve_generator_1, 9), (self.qtgui_bercurve_sink_0, 77)) self.connect((self.fec_bercurve_generator_1, 10), (self.qtgui_bercurve_sink_0, 78)) self.connect((self.fec_bercurve_generator_1, 11), (self.qtgui_bercurve_sink_0, 79)) self.connect((self.fec_bercurve_generator_1, 12), (self.qtgui_bercurve_sink_0, 80)) self.connect((self.fec_bercurve_generator_1, 13), (self.qtgui_bercurve_sink_0, 81)) self.connect((self.fec_bercurve_generator_1, 14), (self.qtgui_bercurve_sink_0, 82)) self.connect((self.fec_bercurve_generator_1, 15), (self.qtgui_bercurve_sink_0, 83)) self.connect((self.fec_bercurve_generator_1, 16), (self.qtgui_bercurve_sink_0, 84)) self.connect((self.fec_bercurve_generator_1, 17), (self.qtgui_bercurve_sink_0, 85)) self.connect((self.fec_bercurve_generator_1, 18), (self.qtgui_bercurve_sink_0, 86)) self.connect((self.fec_bercurve_generator_1, 19), (self.qtgui_bercurve_sink_0, 87)) self.connect((self.fec_bercurve_generator_1, 20), (self.qtgui_bercurve_sink_0, 88)) self.connect((self.fec_bercurve_generator_1, 21), (self.qtgui_bercurve_sink_0, 89)) self.connect((self.fec_bercurve_generator_1, 22), (self.qtgui_bercurve_sink_0, 90)) self.connect((self.fec_bercurve_generator_1, 23), (self.qtgui_bercurve_sink_0, 91)) self.connect((self.fec_bercurve_generator_1, 24), (self.qtgui_bercurve_sink_0, 92)) self.connect((self.fec_bercurve_generator_1, 25), (self.qtgui_bercurve_sink_0, 93)) self.connect((self.fec_bercurve_generator_1, 26), (self.qtgui_bercurve_sink_0, 94)) self.connect((self.fec_bercurve_generator_1, 27), (self.qtgui_bercurve_sink_0, 95)) self.connect((self.fec_bercurve_generator_1, 28), (self.qtgui_bercurve_sink_0, 96)) self.connect((self.fec_bercurve_generator_1, 29), (self.qtgui_bercurve_sink_0, 97)) self.connect((self.fec_bercurve_generator_1, 30), (self.qtgui_bercurve_sink_0, 98)) self.connect((self.fec_bercurve_generator_1, 31), (self.qtgui_bercurve_sink_0, 99)) self.connect((self.fec_bercurve_generator_1, 32), (self.qtgui_bercurve_sink_0, 100)) self.connect((self.fec_bercurve_generator_1, 33), (self.qtgui_bercurve_sink_0, 101))
def assign(self): self.dir = os.path.join(self.directory, f'gr-{self.info["modname"]}') if self.srcdir is None: self.srcdir = os.path.join(gr.prefix(),'share','gnuradio','modtool','templates','gr-newmod')
def __init__(self, frame_size=60, puncpat='11'): gr.top_block.__init__(self, "Fecapi Ldpc Encoders") Qt.QWidget.__init__(self) self.setWindowTitle("Fecapi Ldpc Encoders") 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", "fecapi_ldpc_encoders") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Parameters ################################################## self.frame_size = frame_size self.puncpat = puncpat ################################################## # Variables ################################################## self.H = H = fec.ldpc_H_matrix( gr.prefix() + "/share/gnuradio/fec/ldpc/" + "n_0100_k_0042_gap_02.alist", 2) self.G = G = fec.ldpc_G_matrix(gr.prefix() + "/share/gnuradio/fec/ldpc/" + "n_0100_k_0058_gen_matrix.alist") self.samp_rate = samp_rate = 50000 self.ldpc_enc_H = ldpc_enc_H = fec.ldpc_par_mtrx_encoder_make_H(H) self.ldpc_enc_G = ldpc_enc_G = fec.ldpc_gen_mtrx_encoder_make(G) self.ldpc_enc = ldpc_enc = fec.ldpc_encoder_make( gr.prefix() + "/share/gnuradio/fec/ldpc/" + "n_0100_k_0042_gap_02.alist") self.H_0 = H_0 = fec.ldpc_H_matrix( '/home/mbkitine/Dropbox/Lulea/GRC/DeepSpace/gr-ccsds/examples/LDPC/sim_matlab/AR4JA/python/AR4JA_r45_k1024n.a', 3) ################################################## # Blocks ################################################## self.qtgui_time_sink_x_0_0_1 = qtgui.time_sink_f( 2048, #size samp_rate, #samp_rate '', #name 1 #number of inputs ) self.qtgui_time_sink_x_0_0_1.set_update_time(0.05) self.qtgui_time_sink_x_0_0_1.set_y_axis(-0.5, 1.5) self.qtgui_time_sink_x_0_0_1.set_y_label('Amplitude', "") self.qtgui_time_sink_x_0_0_1.enable_tags(-1, True) self.qtgui_time_sink_x_0_0_1.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, 'packet_len') self.qtgui_time_sink_x_0_0_1.enable_autoscale(False) self.qtgui_time_sink_x_0_0_1.enable_grid(False) self.qtgui_time_sink_x_0_0_1.enable_axis_labels(True) self.qtgui_time_sink_x_0_0_1.enable_control_panel(False) if not True: self.qtgui_time_sink_x_0_0_1.disable_legend() labels = ['LDPC (G)', 'CC', '', '', '', '', '', '', '', ''] 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, 0.6, 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_time_sink_x_0_0_1.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_time_sink_x_0_0_1.set_line_label(i, labels[i]) self.qtgui_time_sink_x_0_0_1.set_line_width(i, widths[i]) self.qtgui_time_sink_x_0_0_1.set_line_color(i, colors[i]) self.qtgui_time_sink_x_0_0_1.set_line_style(i, styles[i]) self.qtgui_time_sink_x_0_0_1.set_line_marker(i, markers[i]) self.qtgui_time_sink_x_0_0_1.set_line_alpha(i, alphas[i]) self._qtgui_time_sink_x_0_0_1_win = sip.wrapinstance( self.qtgui_time_sink_x_0_0_1.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_time_sink_x_0_0_1_win) self.qtgui_time_sink_x_0 = qtgui.time_sink_f( 2048, #size samp_rate, #samp_rate '', #name 2 #number of inputs ) self.qtgui_time_sink_x_0.set_update_time(0.05) self.qtgui_time_sink_x_0.set_y_axis(-0.5, 1.5) self.qtgui_time_sink_x_0.set_y_label('Amplitude', "") self.qtgui_time_sink_x_0.enable_tags(-1, True) self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "") self.qtgui_time_sink_x_0.enable_autoscale(False) self.qtgui_time_sink_x_0.enable_grid(False) self.qtgui_time_sink_x_0.enable_axis_labels(True) self.qtgui_time_sink_x_0.enable_control_panel(False) if not True: self.qtgui_time_sink_x_0.disable_legend() labels = ['LDPC (alist)', 'LDPC (H)', '', '', '', '', '', '', '', ''] 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, 0.6, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] for i in xrange(2): if len(labels[i]) == 0: self.qtgui_time_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_time_sink_x_0.set_line_label(i, labels[i]) self.qtgui_time_sink_x_0.set_line_width(i, widths[i]) self.qtgui_time_sink_x_0.set_line_color(i, colors[i]) self.qtgui_time_sink_x_0.set_line_style(i, styles[i]) self.qtgui_time_sink_x_0.set_line_marker(i, markers[i]) self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_time_sink_x_0_win = sip.wrapinstance( self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_time_sink_x_0_win) self.fec_extended_encoder_1 = fec.extended_encoder( encoder_obj_list=ldpc_enc_H, threading=None, puncpat=puncpat) self.fec_extended_encoder_0_0_0 = fec.extended_encoder( encoder_obj_list=ldpc_enc, threading=None, puncpat=puncpat) self.fec_extended_encoder_0 = fec.extended_encoder( encoder_obj_list=ldpc_enc_G, threading=None, puncpat=puncpat) self.blocks_unpack_k_bits_bb_0 = blocks.unpack_k_bits_bb(8) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_char * 1, samp_rate, True) self.blocks_char_to_float_1_0_0 = blocks.char_to_float(1, 1) self.blocks_char_to_float_1 = blocks.char_to_float(1, 1) self.blocks_char_to_float_0 = blocks.char_to_float(1, 1) self.analog_random_source_x_0 = blocks.vector_source_b( map(int, numpy.random.randint(0, 256, 1000)), True) ################################################## # Connections ################################################## self.connect((self.analog_random_source_x_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_char_to_float_0, 0), (self.qtgui_time_sink_x_0, 1)) self.connect((self.blocks_char_to_float_1, 0), (self.qtgui_time_sink_x_0_0_1, 0)) self.connect((self.blocks_char_to_float_1_0_0, 0), (self.qtgui_time_sink_x_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_unpack_k_bits_bb_0, 0)) self.connect((self.blocks_unpack_k_bits_bb_0, 0), (self.fec_extended_encoder_0, 0)) self.connect((self.blocks_unpack_k_bits_bb_0, 0), (self.fec_extended_encoder_0_0_0, 0)) self.connect((self.blocks_unpack_k_bits_bb_0, 0), (self.fec_extended_encoder_1, 0)) self.connect((self.fec_extended_encoder_0, 0), (self.blocks_char_to_float_1, 0)) self.connect((self.fec_extended_encoder_0_0_0, 0), (self.blocks_char_to_float_1_0_0, 0)) self.connect((self.fec_extended_encoder_1, 0), (self.blocks_char_to_float_0, 0))
import gi gi.require_version("Gtk", "3.0") gi.require_version("PangoCairo", "1.0") from gi.repository import GLib from gnuradio import gr from gnuradio.grc.gui.Platform import Platform from gnuradio.grc.gui.Application import Actions, Application # include the necessary boilerplate from grc's main function to create the app platform = Platform( version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()), prefs=gr.prefs(), install_prefix=gr.prefix(), ) platform.build_library() # pick an example that runs a bunch of qt-gui sinks example_grc_path = (pathlib.Path(gr.prefix()) / "share" / "gnuradio" / "examples" / "qt-gui" / "qtgui_multi_input.grc") app = Application((example_grc_path, ), platform) # script what we want to try out with the app def script(app): # ensure the app is initialized before proceeding while not app.init: time.sleep(1) # add a block and undo it win = app.get_active_window()
def _run_pybind(self): """ Do everything that needs doing in the python bindings subdir. - add blockname_python.cc - add reference and call to bind_blockname() - include them into CMakeLists.txt """ # Generate bindings cc file fname_cc = self.info['blockname'] + '_python.cc' fname_pydoc_h = os.path.join( 'docstrings', self.info['blockname'] + '_pydoc_template.h') # Update python_bindings.cc ed = CPPFileEditor(self._file['ccpybind']) ed.append_value( '// BINDING_FUNCTION_PROTOTYPES(', '// ) END BINDING_FUNCTION_PROTOTYPES', 'void bind_' + self.info['blockname'] + '(py::module& m);') ed.append_value('// BINDING_FUNCTION_CALLS(', '// ) END BINDING_FUNCTION_CALLS', 'bind_' + self.info['blockname'] + '(m);') ed.write() self.scm.mark_files_updated((self._file['ccpybind'])) bg = BindingGenerator(prefix=gr.prefix(), namespace=['gr', self.info['modname']], prefix_include_root=self.info['modname']) block_base = "" if self.info['blocktype'] in ('source', 'sink', 'sync', 'decimator', 'interpolator', 'general', 'hier', 'tagged_stream'): block_base = code_generator.GRTYPELIST[self.info['blocktype']] import hashlib header_file = self.info['blockname'] + '.h' hasher = hashlib.md5() with open(os.path.join(self.info['includedir'], header_file), 'rb') as file_in: buf = file_in.read() hasher.update(buf) md5hash = hasher.hexdigest() header_info = { "module_name": self.info['modname'], "filename": header_file, "md5hash": md5hash, "namespace": { "name": "::".join(['gr', self.info['modname']]), "enums": [], "variables": [], "classes": [{ "name": self.info['blockname'], "member_functions": [{ "name": "make", "return_type": "::".join(("gr", self.info['modname'], self.info['blockname'], "sptr")), "has_static": "1", "arguments": [] }], "bases": ["::", "gr", block_base], "constructors": [{ "name": self.info['blockname'], "arguments": [] }] }], "free_functions": [], "namespaces": [] } } # def gen_pybind_cc(self, header_info, base_name): pydoc_txt = bg.gen_pydoc_h(header_info, self.info['blockname']) path_to_file = os.path.join('python', 'bindings', fname_pydoc_h) logger.info("Adding file '{}'...".format(path_to_file)) with open(path_to_file, 'w') as f: f.write(pydoc_txt) self.scm.add_files((path_to_file, )) cc_txt = bg.gen_pybind_cc(header_info, self.info['blockname']) path_to_file = os.path.join('python', 'bindings', fname_cc) logger.info("Adding file '{}'...".format(path_to_file)) with open(path_to_file, 'w') as f: f.write(cc_txt) self.scm.add_files((path_to_file, )) if not self.skip_cmakefiles: ed = CMakeFileEditor(self._file['cmpybind']) cmake_list_var = 'APPEND {}_python_files'.format( self.info['modname']) ed.append_value('list', fname_cc, to_ignore_start=cmake_list_var, to_ignore_end='python_bindings.cc') ed.write() self.scm.mark_files_updated((self._file['cmpybind']))
def __init__(self, doc, ip="127.0.0.1"): gr.top_block.__init__(self, "RL Mod training") self.doc = doc self.plot_lst = [] self.widget_lst = [] ################################################## # Parameters ################################################## self.ip = ip ################################################## # Variables ################################################## self.pilot_symbols = pilot_symbols = ((1, 1, 1, -1,),) self.pilot_carriers = pilot_carriers = ((-21, -7, 7, 21,),) self.packet_length_tag_key = packet_length_tag_key = "packet_length" self.occupied_carriers = occupied_carriers = (list(range(-22, -21)) + list(range(-20, -7)) + list(range(-6, 0)) + list(range(1, 7)) + list(range(8, 21)) + list(range(22, 23)),) self.length_tag_key_0 = length_tag_key_0 = "frame_len" self.length_tag_key = length_tag_key = "packet_len" self.header_mod = header_mod = digital.constellation_bpsk() self.fft_len = fft_len = 64 self.bits_per_symbol = bits_per_symbol = 4 self.variable_0 = variable_0 = len(occupied_carriers[0]) self.tx_lr = tx_lr = -3 self.tx_explo = tx_explo = 0.15 self.training_mod = training_mod = 1 self.timestamp = timestamp = '1' self.t_state = t_state = 1 self.sync_word2 = sync_word2 = [0, 0, 0, 0, 0, 0, -1, -1, -1, -1, 1, 1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 0, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, 0, 0, 0, 0, 0] self.sync_word1 = sync_word1 = [0., 0., 0., 0., 0., 0., 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 0., 0., 0., 0., 0.] self.samp_rate = samp_rate = 0.3e6 self.rolloff = rolloff = 0 self.puncpat = puncpat = '11' self.payload_mod = payload_mod = digital.qam_constellation(constellation_points=2**bits_per_symbol) self.payload_equalizer = payload_equalizer = digital.ofdm_equalizer_static(fft_len, occupied_carriers, pilot_carriers, pilot_symbols, 1) self.packet_len = packet_len = 400 self.ldpc_enc = ldpc_enc = fec.ldpc_encoder_make(gr.prefix() + "/share/gnuradio/fec/ldpc/" + "n_0100_k_0042_gap_02.alist") self.header_formatter = header_formatter = digital.packet_header_ofdm(occupied_carriers, n_syms=1, len_tag_key=packet_length_tag_key, frame_len_tag_key=length_tag_key_0, bits_per_header_sym=header_mod.bits_per_symbol(), bits_per_payload_sym=8, scramble_header=False) self.header_equalizer = header_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, header_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols) self.hdr_format = hdr_format = digital.header_format_ofdm(occupied_carriers, 1, length_tag_key,) self.gain = gain = 10 self.freq = freq = 900e6 self.bits_per_symbol_0 = bits_per_symbol_0 = len(occupied_carriers[0]) ################################################## # Blocks ################################################## self.tx_lr_slider = bokehgui.slider(self.widget_lst, 'TX Learning rate (log)' +":", -5, 0, 0.1, 1, -3) self.tx_lr_slider.add_callback(lambda attr, old, new: self.set_tx_lr(new)) self.tx_explo_slider = bokehgui.slider(self.widget_lst, 'TX Exploration noise' +":", 0.001, 0.5, 0.001, 1, 0.15) self.tx_explo_slider.add_callback(lambda attr, old, new: self.set_tx_explo(new)) self.training_mod_textbox = bokehgui.textbox(self.widget_lst, str(1), 'Alternate training every' +": ") self.training_mod_textbox.add_callback( lambda attr, old, new: self.set_training_mod(int(new))) self._t_state_options = [ 1, 0, ] self._t_state_labels = [ 'On', 'Off', ] self.t_state_radiobutton = bokehgui.radiobutton(self.widget_lst, None, self._t_state_labels, inline = True) self.t_state_radiobutton.add_callback( lambda new: self.set_t_state(int(self._t_state_options[new]))) self.gain_slider = bokehgui.slider(self.widget_lst, 'Amplitude' +":", 0, 90, 0.5, 1, 10) self.gain_slider.add_callback(lambda attr, old, new: self.set_gain(new)) self.zeromq_sub_msg_source_0_1 = zeromq.sub_msg_source("tcp://"+ip+":50002", 100) self.zeromq_pub_msg_sink_0_0 = zeromq.pub_msg_sink('tcp://*:50001', 100) self.uhd_usrp_sink_0 = uhd.usrp_sink( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", args='', channels=list(range(0,1)), ), length_tag_key, ) self.uhd_usrp_sink_0.set_samp_rate(samp_rate) self.uhd_usrp_sink_0.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS) self.uhd_usrp_sink_0.set_center_freq(freq, 0) self.uhd_usrp_sink_0.set_antenna('TX/RX', 0) self.uhd_usrp_sink_0.set_gain(gain, 0) self.timestamp_textbox = bokehgui.textbox(self.widget_lst, str('1'), 'Load timestamp' +": ") self.timestamp_textbox.add_callback( lambda attr, old, new: self.set_timestamp(str(new))) self.learning_tag_numerotation_0 = learning.tag_numerotation('packet_num', packet_len, 4096, "bb") self.learning_rl_mod_0 = learning.rl_mod('packet_num', bits_per_symbol, packet_len, 1, training_mod, 10**tx_lr , tx_explo, t_state , '/home/cyrille/Gnu-Radio/modules/gr-learning/examples/saved_models') self.fft_vxx_0_0 = fft.fft_vcc(fft_len, False, (), True, 1) self.fec_extended_encoder_1_0_0 = fec.extended_encoder(encoder_obj_list=ldpc_enc, threading= None, puncpat=puncpat) self.digital_protocol_formatter_bb_0 = digital.protocol_formatter_bb(hdr_format, length_tag_key) self.digital_ofdm_cyclic_prefixer_0 = digital.ofdm_cyclic_prefixer( fft_len, fft_len + fft_len//4, rolloff, length_tag_key) self.digital_ofdm_carrier_allocator_cvc_0 = digital.ofdm_carrier_allocator_cvc( fft_len, occupied_carriers, pilot_carriers, pilot_symbols, (sync_word1, sync_word2), length_tag_key, True) self.digital_chunks_to_symbols_xx_0 = digital.chunks_to_symbols_bc(header_mod.points(), 1) self.bokehgui_time_const_x_0 = bokehgui.time_sink_c_proc(1024, samp_rate, "Transmitted noiseless constellation", 1) self.bokehgui_time_const_x_0_plot = bokehgui.const_sink_c(self.doc, self.plot_lst, self.bokehgui_time_const_x_0, is_message = False) labels = ['', '', '', '', '', '', '', '', '', ''] legend_list = [] for i in range( 1 ): if len(labels[i]) == 0: if(i % 2 == 0): legend_list.append("Re{{Data {0}}}".format(i/2)) else: legend_list.append("Im{{Data {0}}}".format(i/2)) else: legend_list.append(labels[i]) self.bokehgui_time_const_x_0_plot.initialize(update_time = 500, legend_list = legend_list) self.bokehgui_time_const_x_0_plot.set_y_axis([-2, 2]) self.bokehgui_time_const_x_0_plot.set_y_label('Q Channel' + '(' +""+')') self.bokehgui_time_const_x_0_plot.set_x_label('I Channel' + '(' +""+')') self.bokehgui_time_const_x_0_plot.enable_tags(-1, False) self.bokehgui_time_const_x_0_plot.set_trigger_mode(bokehgui.TRIG_MODE_FREE, bokehgui.TRIG_SLOPE_POS, 0.0, 0, 0, "") self.bokehgui_time_const_x_0_plot.enable_grid(False) self.bokehgui_time_const_x_0_plot.enable_axis_labels(True) self.bokehgui_time_const_x_0_plot.disable_legend(not True) self.bokehgui_time_const_x_0_plot.set_layout(*((0,1,2,2))) colors = ["blue", "red", "green", "black", "cyan", "magenta", "yellow", "blue", "blue", "blue"] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] markers = ['o', 'o', 'o', 'o', 'o', 'o', 'o', 'o', 'o', 'o'] 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 ): self.bokehgui_time_const_x_0_plot.format_line(i, colors[i], widths[i], 'None', markers[i], alphas[i]) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_char*1, samp_rate/6,True) self.blocks_tagged_stream_to_pdu_0_0_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, 'packet_len') self.blocks_tagged_stream_mux_0 = blocks.tagged_stream_mux(gr.sizeof_gr_complex*1, length_tag_key, 0) self.blocks_stream_to_tagged_stream_0_0 = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, packet_len, length_tag_key) self.blocks_repack_bits_bb_0_0_0 = blocks.repack_bits_bb(8, 1, length_tag_key, False, gr.GR_LSB_FIRST) self.blocks_repack_bits_bb_0_0 = blocks.repack_bits_bb(1, bits_per_symbol, '', False, gr.GR_LSB_FIRST) self.blocks_multiply_const_xx_0 = blocks.multiply_const_cc(0.01, 1) self.analog_random_source_x_0_0 = blocks.vector_source_b(list(map(int, numpy.random.randint(0, 2, 1000))), True) if self.widget_lst: input_t = bokehgui.bokeh_layout.widgetbox(self.widget_lst) widgetbox = bokehgui.bokeh_layout.WidgetLayout(input_t) widgetbox.set_layout(*((0, 0, 2, 1))) list_obj = [widgetbox] + self.plot_lst else: list_obj = self.plot_lst layout_t = bokehgui.bokeh_layout.create_layout(list_obj, "fixed") self.doc.add_root(layout_t) ################################################## # Connections ################################################## self.msg_connect((self.blocks_tagged_stream_to_pdu_0_0_0, 'pdus'), (self.zeromq_pub_msg_sink_0_0, 'in')) self.msg_connect((self.zeromq_sub_msg_source_0_1, 'out'), (self.learning_rl_mod_0, 'losses')) self.connect((self.analog_random_source_x_0_0, 0), (self.fec_extended_encoder_1_0_0, 0)) self.connect((self.blocks_multiply_const_xx_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.blocks_repack_bits_bb_0_0, 0), (self.blocks_stream_to_tagged_stream_0_0, 0)) self.connect((self.blocks_repack_bits_bb_0_0_0, 0), (self.digital_chunks_to_symbols_xx_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0_0, 0), (self.digital_protocol_formatter_bb_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0_0, 0), (self.learning_tag_numerotation_0, 0)) self.connect((self.blocks_tagged_stream_mux_0, 0), (self.digital_ofdm_carrier_allocator_cvc_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_tagged_stream_to_pdu_0_0_0, 0)) self.connect((self.digital_chunks_to_symbols_xx_0, 0), (self.blocks_tagged_stream_mux_0, 0)) self.connect((self.digital_ofdm_carrier_allocator_cvc_0, 0), (self.fft_vxx_0_0, 0)) self.connect((self.digital_ofdm_cyclic_prefixer_0, 0), (self.blocks_multiply_const_xx_0, 0)) self.connect((self.digital_protocol_formatter_bb_0, 0), (self.blocks_repack_bits_bb_0_0_0, 0)) self.connect((self.fec_extended_encoder_1_0_0, 0), (self.blocks_repack_bits_bb_0_0, 0)) self.connect((self.fft_vxx_0_0, 0), (self.digital_ofdm_cyclic_prefixer_0, 0)) self.connect((self.learning_rl_mod_0, 0), (self.blocks_tagged_stream_mux_0, 1)) self.connect((self.learning_rl_mod_0, 1), (self.bokehgui_time_const_x_0, 0)) self.connect((self.learning_tag_numerotation_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.learning_tag_numerotation_0, 0), (self.learning_rl_mod_0, 0))
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", type=QtCore.QByteArray)) ################################################## # Variables ################################################## self.H_dec = H_dec = fec.ldpc_H_matrix(gr.prefix() + "/share/gnuradio/fec/ldpc/" + "n_0100_k_0042_gap_02.alist", 2) self.H = H = fec.ldpc_H_matrix(gr.prefix() + "/share/gnuradio/fec/ldpc/" + "n_0100_k_0042_gap_02.alist", 2) self.samp_rate = samp_rate = 320000 self.rate = rate = 2 self.puncpat = puncpat = '11' self.polys = polys = [109, 79] self.pld_enc = pld_enc = fec.ldpc_par_mtrx_encoder_make_H(H) self.pld_dec = pld_dec = fec.ldpc_bit_flip_decoder.make(H_dec.get_base_sptr(), 100) self.pld_const = pld_const = digital.constellation_calcdist((digital.psk_2()[0]), (digital.psk_2()[1]), 2, 1).base() self.pld_const.gen_soft_dec_lut(8) self.pkt_len = pkt_len = 42 self.k = k = 7 ################################################## # Blocks ################################################## self.fec_extended_encoder_0 = fec.extended_encoder(encoder_obj_list=pld_enc, threading='capillary', puncpat='11') self.fec_extended_decoder_0_0_1 = fec.extended_decoder(decoder_obj_list=pld_dec, threading= None, ann=None, puncpat=puncpat, integration_period=10000) self.digital_map_bb_1_0 = digital.map_bb((pld_const.pre_diff_code())) self.digital_constellation_soft_decoder_cf_0 = digital.constellation_soft_decoder_cf(pld_const) self.digital_chunks_to_symbols_xx_0_0 = digital.chunks_to_symbols_bc((pld_const.points()), 1) self.blocks_vector_source_x_0_0 = blocks.vector_source_b([0], True, 1, []) self.blocks_vector_source_x_0 = blocks.vector_source_b([0], True, 1, []) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_char*1, samp_rate,True) self.blocks_tag_gate_0 = blocks.tag_gate(gr.sizeof_gr_complex * 1, True) self.blocks_tag_gate_0.set_single_key("") self.blocks_tag_debug_0_0 = blocks.tag_debug(gr.sizeof_float*1, 'SAI_DECODER', ""); self.blocks_tag_debug_0_0.set_display(True) self.blocks_tag_debug_0 = blocks.tag_debug(gr.sizeof_char*1, 'PLD_ENCODED', ""); self.blocks_tag_debug_0.set_display(True) self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, 42, "packet_len") self.blocks_stream_mux_0_0 = blocks.stream_mux(gr.sizeof_char*1, (100, 4)) self.blocks_stream_mux_0 = blocks.stream_mux(gr.sizeof_char*1, (40, 2)) self.blocks_repack_bits_bb_1_0 = blocks.repack_bits_bb(8, 1, '', False, gr.GR_MSB_FIRST) self.blocks_repack_bits_bb_0_1_1_0_0 = blocks.repack_bits_bb(1, 8, '', False, gr.GR_MSB_FIRST) self.blocks_repack_bits_bb_0_0_0 = blocks.repack_bits_bb(1, 8, '', True, gr.GR_MSB_FIRST) self.blocks_repack_bits_bb_0_0 = blocks.repack_bits_bb(8, pld_const.bits_per_symbol(), '', False, gr.GR_MSB_FIRST) self.blocks_keep_m_in_n_0_0 = blocks.keep_m_in_n(gr.sizeof_float, 100, 104, 0) self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_char, 40, 42, 0) self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char*1, '/home/andre/Desktop/letra.txt', False) self.blocks_file_source_0.set_begin_tag(pmt.PMT_NIL) self.blocks_file_sink_0_0 = blocks.file_sink(gr.sizeof_char*1, '/home/andre/Desktop/transmitido/teste.txt', False) self.blocks_file_sink_0_0.set_unbuffered(False) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char*1, '/home/andre/Desktop/transmitido/depois.txt', False) self.blocks_file_sink_0.set_unbuffered(False) ################################################## # Connections ################################################## self.connect((self.blocks_file_source_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_keep_m_in_n_0, 0), (self.blocks_repack_bits_bb_0_1_1_0_0, 0)) self.connect((self.blocks_keep_m_in_n_0_0, 0), (self.fec_extended_decoder_0_0_1, 0)) self.connect((self.blocks_repack_bits_bb_0_0, 0), (self.digital_map_bb_1_0, 0)) self.connect((self.blocks_repack_bits_bb_0_0_0, 0), (self.blocks_repack_bits_bb_0_0, 0)) self.connect((self.blocks_repack_bits_bb_0_0_0, 0), (self.blocks_tag_debug_0, 0)) self.connect((self.blocks_repack_bits_bb_0_1_1_0_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.blocks_repack_bits_bb_1_0, 0), (self.blocks_stream_mux_0, 0)) self.connect((self.blocks_stream_mux_0, 0), (self.blocks_stream_to_tagged_stream_0, 0)) self.connect((self.blocks_stream_mux_0_0, 0), (self.blocks_repack_bits_bb_0_0_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.blocks_file_sink_0_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.fec_extended_encoder_0, 0)) self.connect((self.blocks_tag_gate_0, 0), (self.digital_constellation_soft_decoder_cf_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_repack_bits_bb_1_0, 0)) self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_stream_mux_0, 1)) self.connect((self.blocks_vector_source_x_0_0, 0), (self.blocks_stream_mux_0_0, 1)) self.connect((self.digital_chunks_to_symbols_xx_0_0, 0), (self.blocks_tag_gate_0, 0)) self.connect((self.digital_constellation_soft_decoder_cf_0, 0), (self.blocks_keep_m_in_n_0_0, 0)) self.connect((self.digital_constellation_soft_decoder_cf_0, 0), (self.blocks_tag_debug_0_0, 0)) self.connect((self.digital_map_bb_1_0, 0), (self.digital_chunks_to_symbols_xx_0_0, 0)) self.connect((self.fec_extended_decoder_0_0_1, 0), (self.blocks_keep_m_in_n_0, 0)) self.connect((self.fec_extended_encoder_0, 0), (self.blocks_stream_mux_0_0, 0))
def __init__(self, decoderType, packetLength, rate): gr.hier_block2.__init__(self, "FECDecoder", gr.io_signature(1, 1, gr.sizeof_float*1), gr.io_signature(1, 1, gr.sizeof_char*1), ) ################################################## # Parameters ################################################## self.packetLength = packetLength self.rate = rate self.decoderType = decoderType if decoderType == "cc": if(rate == 0.5): # Rate 1/2 self.puncpat = puncpat = '11' elif(rate == 0.75): # Rate 3/4 self.puncpat = puncpat = '101' elif(rate == 0.875): # Rate 7/8 self.puncpat = puncpat = '1010101' else: raise ValueError, "Unsupported coding rate '%f' for CC" % (rate,) elif decoderType == "ldpc": if(rate == 0.42): # Rate 0.42 self.puncpat = puncpat = '11' else: raise ValueError, "Unsupported coding rate '%f' for LDPC" % (rate,) else: raise ValueError, "Unsupported channel encoder %s" % (decoderType,) if(decoderType == "cc"): ################################################## # Variables ################################################## self.polys = polys = [109, 79] self.k = k = 7 self.dec_cc = dec_cc = fec.cc_decoder.make(packetLength*8, 7, 2, (polys), 0, -1, fec.CC_TAILBITING, False) ################################################## # Blocks ################################################## self.fec_extended_decoder = fec.extended_decoder(decoder_obj_list=dec_cc, threading= None, ann=None, puncpat=puncpat, integration_period=10000) self.blocks_unpacked_to_packed_xx = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST) ################################################## # Connections ################################################## self.connect((self.blocks_unpacked_to_packed_xx, 0), (self, 0)) self.connect((self.fec_extended_decoder, 0), (self.blocks_unpacked_to_packed_xx, 0)) self.connect((self, 0), (self.fec_extended_decoder, 0)) else: ################################################## # Variables ################################################## self.ldpc_dec = ldpc_dec = fec.ldpc_decoder.make(gr.prefix() + "/share/gnuradio/fec/ldpc/" + "n_0100_k_0042_gap_02.alist", 0.5, 50); ################################################## # Blocks ################################################## self.SatelliteModem_depadForLDPC_0 = SatelliteModem.depadForLDPC(packetLength*8, 42) self.fec_extended_decoder = fec.extended_decoder(decoder_obj_list=ldpc_dec, threading= None, ann=None, puncpat=puncpat, integration_period=10000) self.blocks_unpacked_to_packed_xx = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST) ################################################## # Connections ################################################## self.connect((self.blocks_unpacked_to_packed_xx, 0), (self, 0)) self.connect((self.fec_extended_decoder, 0), (self.SatelliteModem_depadForLDPC_0, 0)) self.connect((self.SatelliteModem_depadForLDPC_0, 0), (self.blocks_unpacked_to_packed_xx, 0)) self.connect((self, 0), (self.fec_extended_decoder, 0))