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
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))
