"""

class GNURadioControlPortClient(object):

"""

Constructor for creating a ControlPort connection to a specified host / port

such as QtGui.QApplication.exec_

"""

def __init__(self, host=None, port=None, rpcmethod='thrift', callback=None, blockingcallback=None):

self.client = None

from gnuradio import blocks

from gnuradio import filter, fft

from gnuradio.ctrlport.GNURadio import ControlPort

try:

from gnuradio import qtgui

print("Error: Program requires PyQt5 and gr-qtgui.")

sys.exit(1)

class GrDataPlotParent(gr.top_block, Qt.QWidget):

# Setup signals

plotupdated = QtCore.pyqtSignal(Qt.QWidget)

self._name = name

self._npts = 500

self._rate = rate

self.layout = Qt.QVBoxLayout()

self.setLayout(self.layout)

self.disconnect(self.thr, (self.snk, 0))

self.disconnect(self.src[0], self.thr)

for n in range(1, self._ncons):

self._ncons = nconnections

self.thr = blocks.throttle(self._datasize, self._rate)

self.snk = self.get_qtsink()

for n in range(self._ncons):

self.set_line_label(n, self.knobnames[n])

self.src.append(self.get_vecsource())

if(n == 0):

self.connect(self.src[n], self.thr)

else:

self.py_window = sip.wrapinstance(self.snk.qwidget(), Qt.QWidget)

if(self._iscomplex):

data_r = data[0::2]

data_i = data[1::2]

return data

def update(self, data):

if(self._data_len[n] < npts):

self._last_data[n] = self._last_data[n][0:npts]

else:

self._data_len[n] = npts

else:

self._npts = npts

self.snk.reset()

self.src[n].set_data(data[n])

self._last_data[n] = data[n][-self._npts:]

else:

newdata += data[n]

self.src[n].set_data(newdata)

self._last_data[n] = newdata

if(self._iscomplex):

data[n] = complex(data[n][0], data[n][1])

if(self._data_len[n] < self._npts):

else:

for n in range(self._ncons):

if(type(data[n]) != list):

data[n] = self.data_to_complex(data[n])

self.src[n].set_data(data[n])

class GrDataPlotterC(GrDataPlotParent):

def __init__(self, name, rate, pmin=None, pmax=None, stripchart=False):

GrDataPlotParent.__init__(self, name, rate, pmin, pmax)

return self._npts

def set_line_label(self, n, name):

class GrDataPlotterF(GrDataPlotParent):

def set_line_label(self, n, name):

self.snk.set_line_label(n, self.knobnames[n])

class GrTimeRasterB(GrDataPlotParent):

def __init__(self, name, rate, pmin=None, pmax=None):

GrDataPlotParent.__init__(self, name, rate, pmin, pmax)

self.uid = uid

self.treeWidget = Qt.QTreeWidget(parent)

self.treeWidget.setColumnCount(len(headers))

self.treeWidget.setHeaderLabels(headers)

self.treeWidget.resizeColumnToContents(0)

descr = str(knobprops[itemKey].description)

if(type(v) == ControlPort.complex):

# If it's a byte stream, Python thinks it's a string.

# Unpack and convert to floats for plotting.

# Ignore the edge list knob if it's being exported

elif(type(v) == str and itemKey.find('probe2_b') == 0):

# Convert the final value to a string for displaying

v = str(v)

if (item.text(1) != v or

item.text(2) != units or

item.setText(1, v)

item.setText(2, units)

if k not in foundKeys:

v = knobs[k].value

if(type(v) == ControlPort.complex):

# If it's a byte stream, Python thinks it's a string.

# Unpack and convert to floats for plotting.

# Ignore the edge list knob if it's being exported

elif(type(v) == str and k.find('probe2_b') == 0):

item = Qt.QTreeWidgetItem([k, str(v),

self.treeWidget.addTopLevelItem(item)

# Remove items currently in tree that are not in the knob list.

for itemKey in deleteKeys:

if (len(qtwiList) > 1):

raise Exception('More than one item with key %s in tree' %

itemKey)

RPCMethods = {'thrift': 'Apache Thrift',

"""

host: hostname of the connection

"""

class RPCConnection(object):

def __init__(self, method, port, host=None):

(self.method, self.port) = (method, port)

def __str__(self):

def getName(self):

return RPCMethods[self.method]

def getKnobs(self, *args):

raise NotImplementedError()

raise NotImplementedError()

raise NotImplementedError()

raise NotImplementedError()

def shutdown(self):

import pmt

import sys

class ThriftRadioClient(object):

def __init__(self, host, port):

self.tsocket = TSocket.TSocket(host, port)

def getRadio(self):

return self.radio

"""

RPC Client interface for the Apache Thrift middle-ware RPC transport.

host: hostname of the connection

"""

class RPCConnectionThrift(RPCConnection.RPCConnection):

class Knob(object):

def __init__(self, key, value=None, ktype=0):

else:

port = int(port)

self.newConnection(host, port)

self.unpack_dict = {

}

self.pack_dict = {

}

def __str__(self):

if(f):

return f(key, knob)

else:

raise exceptions.ValueError

def packKnob(self, knob):

if(f):

return f(knob)

else:

raise exceptions.ValueError

def newConnection(self, host=None, port=None):

#print("key:", key, "value:", knobprop, "type:", knobprop.type)

knobprops[key].min = self.unpackKnob(key, knobprop.min)

knobprops[key].max = self.unpackKnob(key, knobprop.max)

return knobprops

def getKnobs(self, *args):

result[key] = knob

return result

result = {}

for key, knob in list(self.thriftclient.radio.getRe(*args).items()):

result[key] = self.unpackKnob(key, knob)

result[k.key] = self.packKnob(k)

self.thriftclient.radio.setKnobs(result)

else:

def shutdown(self):

self.thriftclient.radio.shutdown()

serialized. The msg is already a PMT and so just serialized.

'''

self.thriftclient.radio.postMessage(pmt.serialize_str(pmt.intern(blk_alias)),

pmt.serialize_str(msg))

def printProperties(self, props):

info = ""

info += "Item:\t\t{0}\n".format(props.description)

from PyQt5 import QtCore, Qt

from argparse import ArgumentParser

from gnuradio import gr, ctrlport

from gnuradio.ctrlport.GrDataPlotter import *

from gnuradio.ctrlport.GNURadioControlPortClient import GNURadioControlPortClient

class RateDialog(Qt.QDialog):

def __init__(self, delay, parent=None):

super(RateDialog, self).__init__(parent)

self.setWindowTitle("Update Delay (ms)")

self.delay = Qt.QLineEdit(self)

self.delay.setText(str(delay))

self.gridLayout.addWidget(self.delay)

self.gridLayout.addWidget(self.buttonBox)

self.buttonBox.accepted.connect(self.accept)

self.buttonBox.rejected.connect(self.reject)

def accept(self):

self.done(1)

def reject(self):

self.done(0)

class MAINWindow(Qt.QMainWindow):

def minimumSizeHint(self):

def __init__(self, radioclient):

self.setUnifiedTitleAndToolBarOnMac(True)

self.newCon(radioclient)

self.setWindowIcon(icon)

# Locally turn off ControlPort export from GR. This prevents

# been specified).

os.environ['GR_CONF_CONTROLPORT_ON'] = 'False'

self.updateRate = int(nur)

for c in self.conns:

c.updateRate = self.updateRate

c.timer.setInterval(self.updateRate)

def newCon(self, radioclient=None):

if(child.radioclient is not None):

child.setWindowTitle(str(child.radioclient))

self.mdiArea.addSubWindow(child)

props = radio.properties([key])

# Use display option mask of item to set up available plot

# types and default options.

knobprop = self.knobprops[uid][tag]

strr = str(tree.radioclient)

disp = knobprop.display

if(disp & gr.DISPTIME):

self.mdiArea.addSubWindow(plot)

plot.setWindowTitle("{0}: {1}".format(title, plot.name()))

# when the plot is updated via drag-and-drop, we need to be

# notified of the new qwidget that's created so we can

for i, plots in enumerate(self.plots):

for p in plots:

if(p == q):

q.qwidget().destroyed.connect(lambda obj=None, plot=p: self.destroyPlot(plot=plot))

break

# If it's a byte stream, Python thinks it's a string.

# Unpack and convert to floats for plotting.

if(type(d) == str and n.find('probe2_b') == 0):

d = [float(di) for di in d]

data.append(d)

if window:

self.mdiArea.setActiveSubWindow(window)

def createActions(self):

self.newConAct = Qt.QAction("&New Connection",

self.exitAct = Qt.QAction("E&xit", self, shortcut="Ctrl+Q",

self.closeAct = Qt.QAction("Cl&ose", self, shortcut="Ctrl+F4",

self.closeAllAct = Qt.QAction("Close &All", self,

self.urAct = Qt.QAction("Update Rate", self, shortcut="F5",

qks = Qt.QKeySequence(QtCore.Qt.CTRL + QtCore.Qt.Key_T)

self.tileAct = Qt.QAction("&Tile", self,

qks = Qt.QKeySequence(QtCore.Qt.CTRL + QtCore.Qt.Key_C)

self.cascadeAct = Qt.QAction("&Cascade", self,

self.nextAct = Qt.QAction("Ne&xt", self,

self.previousAct = Qt.QAction("Pre&vious", self,

self.separatorAct = Qt.QAction(self)

self.separatorAct.setSeparator(True)

self.aboutAct = Qt.QAction("&About", self,

self.aboutQtAct = Qt.QAction("About &Qt", self,

def createMenus(self):

self.fileMenu = self.menuBar().addMenu("&File")

def createStatusBar(self):

self.statusBar().showMessage("Ready")

def activeMdiChild(self):

activeSubWindow = self.mdiArea.activeSubWindow()

if activeSubWindow:

def about(self):

about_info = \

This program is part of GNU Radio.\n

GNU Radio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.\n

GNU Radio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n

self.gridLayout = Qt.QGridLayout(self)

self.host = Qt.QLineEdit(self)

self.port = Qt.QLineEdit(self)

self.host.setText("localhost")

self.port.setText("43243")

self.gridLayout.addWidget(self.host)

self.gridLayout.addWidget(self.port)

self.buttonBox.accepted.connect(self.accept)

self.buttonBox.rejected.connect(self.reject)

def accept(self):

self.done(1)

self.key = key

self.radio = radio

self.layout = Qt.QVBoxLayout()

self.props = radio.properties([key])[key]

except:

has_set = False

if(has_set is False):

self.cancelButton = Qt.QPushButton("Ok")

self.cancelButton.clicked.connect(self.reject)

self.buttonlayout.addWidget(self.cancelButton)

self.layout.addLayout(self.buttonlayout)

self.textInput = Qt.QLineEdit()

self.layout.addWidget(self.textInput)

rv = radio.getKnobs([key])

val = rv[key].value

if(type(val) == ControlPort.complex):

self.textInput.setText(str(val))

self.sv = rv[key]

self.setButton.clicked.connect(self._set)

self.cancelButton.clicked.connect(self.reject)

if(self.is_num):

self.sliderlayout = Qt.QHBoxLayout()

self.slider = Qt.QSlider(QtCore.Qt.Horizontal)

self.sliderlayout.addWidget(self.slider)

self.steps = 10000

self.valspan = self.props.max.value - self.props.min.value

self.setLayout(self.layout)

def _set_slider_value(self, val):

def _slide(self):

self.textInput.setText(str(val))

def _apply(self):

val.re = t.real

val.im = t.imag

else:

return

self.sv.value = val

st = time.time()

knobs = self.radioclient.getKnobs([])

ft = time.time()

except Exception as e:

if(type(self.parent) is MAINWindow):

# Find window of connection

remove = []

tableitems = knobs.keys()

self.table.updateItems(knobs, self.knobprops)

self.parent.update(knobs, self.uid)

def __init__(self, radioclient, uid=0, updateRate=2000, parent=None):

super(MForm, self).__init__()

port = str(askinfo.port.text())

try:

print("Connected to %s:%s" % (host, port))

except:

print("Cannot connect to %s:%s" % (host, port))

self.knobprops = self.radioclient.properties([])

self.parent.knobprops.append(self.knobprops)

self.timer = QtCore.QTimer()

self.constupdatediv = 0

self.tableupdatediv = 0

# make table

self.table = GrDataPlotterValueTable(uid, self, 0, 0, 400, 200)

self.table.treeWidget.setSizePolicy(sizePolicy)

self.table.treeWidget.setSortingEnabled(True)

self.table.treeWidget.setDragEnabled(True)

if pmin == []:

pmin = None

else:

if pmax == []:

pmax = None

else:

return pmin, pmax

class MyApp(object):

def __init__(self, args):

parser = ArgumentParser(description="GNU Radio Control Port Monitor")

parser.add_argument("port", help="port")

args = parser.parse_args()

try:

except:

print("ControlPort failed to connect. Check the config of your endpoint.")

print("\t[ControlPort] on = True")

def run(self, client):

MAINWindow(client).show()

MyApp(sys.argv)

from argparse import ArgumentParser

from gnuradio.ctrlport.GNURadioControlPortClient import GNURadioControlPortClient

print(sys.argv[0], "could not load QTAgg backend.")

sys.exit(1)

from matplotlib.figure import Figure

except ImportError:

print(sys.argv[0], "requires networkx and matplotlib.",

sys.exit(1)

from PyQt5 import QtCore, Qt

from networkx.drawing.nx_agraph import graphviz_layout

class MAINWindow(Qt.QMainWindow):

def minimumSizeHint(self):

def __init__(self, radioclient):

self.newCon(radioclient)

self.setWindowIcon(icon)

def newSubWindow(self, window, title):

if window:

self.mdiArea.setActiveSubWindow(window)

def createActions(self):

self.newConAct = Qt.QAction("&New Connection",

self.exitAct = Qt.QAction("E&xit", self, shortcut="Ctrl+Q",

self.closeAct = Qt.QAction("Cl&ose", self, shortcut="Ctrl+F4",

self.closeAllAct = Qt.QAction("Close &All", self,

qks = Qt.QKeySequence(QtCore.Qt.CTRL + QtCore.Qt.Key_T)

self.tileAct = Qt.QAction("&Tile", self,

qks = Qt.QKeySequence(QtCore.Qt.CTRL + QtCore.Qt.Key_C)

self.cascadeAct = Qt.QAction("&Cascade", self,

self.nextAct = Qt.QAction("Ne&xt", self,

self.previousAct = Qt.QAction("Pre&vious", self,

self.separatorAct = Qt.QAction(self)

self.separatorAct.setSeparator(True)

self.aboutAct = Qt.QAction("&About", self,

self.aboutQtAct = Qt.QAction("About &Qt", self,

def createMenus(self):

self.fileMenu = self.menuBar().addMenu("&File")

def createStatusBar(self):

self.statusBar().showMessage("Ready")

def activeMdiChild(self):

activeSubWindow = self.mdiArea.activeSubWindow()

if activeSubWindow:

def about(self):

about_info = \

This program is part of GNU Radio.\n

GNU Radio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.\n

GNU Radio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n

self.gridLayout = Qt.QGridLayout(self)

self.host = Qt.QLineEdit(self)

self.port = Qt.QLineEdit(self)

self.host.setText("localhost")

self.port.setText("43243")

self.buttonBox = Qt.QDialogButtonBox(Qt.QDialogButtonBox.Ok |

self.gridLayout.addWidget(self.host)

self.gridLayout.addWidget(self.port)

self.buttonBox.accepted.connect(self.accept)

self.buttonBox.rejected.connect(self.reject)

def accept(self):

self.done(1)

self.perfTable = Qt.QTableWidget()

self.perfTable.setColumnCount(2)

self.perfTable.verticalHeader().hide()

self.perfTable.horizontalHeader().setStretchLastSection(True)

self.perfTable.setSortingEnabled(True)

nodes = self.G.nodes(data=True)

# set up plot

self.sp = self.f.add_subplot(111)

self.sp.set_autoscale_on(True)

# set up tabs

self.tabber = Qt.QTabWidget()

self.layout.addWidget(self.tabber)

self.tabber.addTab(self.f.canvas, "Graph View")

# set up timer

for i, node in enumerate(nodes):

self.perfTable.setItem(i, 0,

for k in data.keys():

weight = data[k]

if(len(existing) == 0):

i = self.perfTable.rowCount()

else:

def stat_changed(self, index):

self._statistic = str(self.stattype.currentText())

def checksort_changed(self, state):

self._sort = state > 0

class DataTableBuffers(DataTable):

def __init__(self, radioclient, G):

super(DataTableBuffers, self).__init__(radioclient, G)

def update(self):

nodes = self.G.nodes()

# get buffer fullness for all blocks

try:

buf_knobs = self.radioclient.getKnobs(kl)

except Exception as e:

self.parentWidget().mdiArea().removeSubWindow(self.parentWidget())

self.close()

return

for blk in buffer_fullness:

bdata = buffer_fullness[blk]

if bdata:

if(self.perfTable.isVisible()):

self.table_update(blockport_fullness)

if(self._sort):

sorted_fullness = sorted(blockport_fullness.items(),

key=operator.itemgetter(1))

else:

if self._keymap:

for b in blockport_fullness:

else:

sorted_fullness = blockport_fullness.items()

if(not self.disp):

alpha=0.5, align='edge')

self.sp.set_ylabel("% Buffers Full")

self.sp.set_xticklabels(list(map(lambda x: " " + x, map(lambda x: x[0], sorted_fullness))),

rotation="vertical", verticalalignment="bottom")

else:

self.sp.set_xticklabels(list(map(lambda x: " " + x, map(lambda x: x[0], sorted_fullness))),

rotation="vertical", verticalalignment="bottom")

r.set_height(w[1])

self.f.canvas.draw()

class DataTableRuntimes(DataTable):

def __init__(self, radioclient, G):

def update(self):

nodes = self.G.nodes()

# get work time for all blocks

try:

wrk_knobs = self.radioclient.getKnobs(kl)

except Exception as e:

self.parentWidget().mdiArea().removeSubWindow(self.parentWidget())

self.close()

return

total_work = 1

work_times = dict(zip(

map(lambda x: x.split("::")[0], wrk_knobs.keys()),

# update table view

if(self.perfTable.isVisible()):

else:

if(self._sort):

self._keymap = list(map(operator.itemgetter(0), sorted_work))

else:

if self._keymap:

for b in work_times:

sorted_work[self._keymap.index(b)] = (b, work_times[b])

else:

sorted_work = work_times.items()

if(not self.disp):

list(map(lambda x: x[1], sorted_work)),

alpha=0.5, align='edge')

self.sp.set_ylabel("% Runtime")

self.sp.set_xticklabels(list(map(lambda x: " " + x[0], sorted_work)),

else:

self.sp.set_xticklabels(list(map(lambda x: " " + x[0], sorted_work)),

r.set_height(w[1])

self.f.canvas.draw()

class MForm(Qt.QWidget):

def update(self):

try:

kl1 = self.radioclient.getKnobs([self.clockKey])

self.clockKey = list(kl1.keys())[0]

self.currClock = kl1[self.clockKey].value

self.clockSel.setCurrentIndex(self.clockSelIdx)

self.prevent_clock_change = False

except Exception as e:

nodes_msg = self.G_msg.nodes()

# get current buffer depths of all output buffers

st = time.time()

buf_knobs = self.radioclient.getKnobs(kl)

map(lambda x: x.value, buf_knobs.values())))

# get work time for all blocks

st = time.time()

wrk_knobs = self.radioclient.getKnobs(kl)

td2 = time.time() - st

if(total_work == 0):

total_work = 1

work_times = dict(zip(

work_times_padded = dict(zip(

work_times_padded.update(work_times)

for n in nodes_stream:

# ne is the list of edges away from this node!

# get the right output buffer/port weight for each edge

sourceport = e[2]["sourceport"]

if(e[2]["type"] == "stream"):

e[2]["weight"] = newweight

for n in nodes_msg:

sourceport = e[2]["sourceport"]

if(e[2]["type"] == "msg"):

newweight = 0.01

# set updated weights

#self.node_weights = map(lambda x: 20+2000*work_times[x], nodes_stream)

# draw graph updates

if(self.do_update):

self.updateGraph()

latency = td1 + td2

except Exception as e:

if(type(self.parent) is MAINWindow):

# Find window of connection

for p in self.parent.mdiArea.subWindowList():

return

def rtt(self):

def bpt(self):

def resetPCs(self):

knobs = []

for b in self.blocks_list:

k = self.radioclient.setKnobs(knobs)

def toggleFlowgraph(self):

host = str(askinfo.host.text())

port = str(askinfo.port.text())

try:

print("Connected to %s:%s" % (host, port))

except:

print("Error connecting to %s:%s" % (host, port))

else:

self.radioclient = radioclient

if self.radioclient is None:

return

self.layoutTop.addLayout(self.layout)

self.rttAct = Qt.QAction("Runtime Table",

self.rttBut = Qt.QToolButton()

self.rttBut.setDefaultAction(self.rttAct)

self.ctlBox.addWidget(self.rttBut)

self.bptAct = Qt.QAction("Buffer Table",

self.bptBut = Qt.QToolButton()

self.bptBut.setDefaultAction(self.bptAct)

self.ctlBox.addWidget(self.bptBut)

self.resetPCsAct = Qt.QAction("Reset", self,

self.resetPCsBut = Qt.QToolButton()

self.resetPCsBut.setDefaultAction(self.resetPCsAct)

self.ctlBox.addWidget(self.resetPCsBut)

self.pauseFGAct = Qt.QAction("Pause", self,

self.pauseFGAct.setCheckable(True)

self.pauseFGBut = Qt.QToolButton()

self.pauseFGBut.setDefaultAction(self.pauseFGAct)

self.prevent_clock_change = True

self.clockKey = None

self.clockSel = Qt.QComboBox(self)

list(map(lambda x: self.clockSel.addItem(x), self.clocks.keys()))

self.ctlBox.addWidget(self.clockSel)

self.timer = QtCore.QTimer()

self.constupdatediv = 0

self.tableupdatediv = 0

# Set up the graph of blocks

tmplist = []

knobs = self.radio.getKnobs([])

if(input_name(blockname) in knobs):

tmplist.append(blockname)

if not edgelist:

sys.exit(1)

self.blocks_list = tmplist

# add stream connections

for e in edges:

_e = e.split("->")

# add msg connections

for e in msgedges:

_e = e.split("->")

self.G = nx.MultiDiGraph()

self.G_stream = nx.MultiDiGraph()

n_edges = self.G.edges(data=True)

for e in n_edges:

self.G = nx.MultiDiGraph()

self.G.add_edges_from(n_edges)

self.sp = self.f.add_subplot(111)

self.sp.set_autoscale_on(True)

self.layout.addWidget(self.f.canvas)

thrsh = 100

if(x is not None and y is not None):

i = nearby.index(min(nearby))

if(abs(list(self.pos.values())[i][0] - x) < thrsh and

self._current_block = list(self.pos.keys())[i]

self._grabbed = True

def mouse_move(self, event):

if self._grabbed:

x, y = event.xdata, event.ydata

if(x is not None and y is not None):

self.updateGraph()

def button_release(self, event):

self._grabbed = False

def openMenu(self, pos):

index = self.table.treeWidget.selectedIndexes()

item = self.table.treeWidget.itemFromIndex(index[0])

nx.draw(self.G, self.pos,

edge_color=self.edge_weights,

node_color='#A0CBE2',

node_shape="s",

node_size=self.node_weights,

edge_cmap=plt.cm.Reds,

ax=self.sp,

arrows=False

nx.draw_networkx_labels(self.G, self.pos,

font_size=12)

nx.draw_networkx_edges(self.G, self.pos,

edge_color=self.edge_weights,

edge_cmap=plt.cm.Reds,

ax=self.sp,

arrows=False)

def __init__(self, args):

parser = ArgumentParser(description="GNU Radio Performance Monitor")

parser.add_argument("port", help="port")

args = parser.parse_args()

signal.signal(signal.SIGTERM, signal.SIG_DFL)

try:

except:

print("ControlPort failed to connect. Check the config of your endpoint.")

print("\t[ControlPort] on = True")

def run(self, client):

MAINWindow(client).show()

MyApp(sys.argv)

#

from gnuradio import gr

class monitor(object):

print("ControlPort Monitor running.")

self.started = False

self.tool = tool

atexit.register(self.shutdown)

# setup export prefs

if(tool == "gr-perf-monitorx"):

def start(self):

try:

ep = gr.rpcmanager_get().endpoints()[0]

self.proc = subprocess.Popen(cmd)

self.started = True

except: