from __future__ import print_function

import random,math,operator

try:

import networkx as nx

import matplotlib

import matplotlib.pyplot as plt

try:

from matplotlib.figure import Figure

"Please check that they are installed and try again.")

sys.exit(1)

import itertools

from gnuradio import gr, ctrlport

from gnuradio.ctrlport.GrDataPlotter import *

def minimumSizeHint(self):

def __init__(self, radioclient):

super(MAINWindow, self).__init__()

self.plots = []

self.knobprops = []

self.mdiArea.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)

self.mdiArea.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)

self.setCentralWidget(self.mdiArea)

self.mdiArea.subWindowActivated.connect(self.updateMenus)

self.windowMapper = QtCore.QSignalMapper(self)

self.createActions()

self.createMenus()

self.newCon(radioclient)

self.setWindowIcon(icon)

def newSubWindow(self, window, title):

child.setWindowTitle(title)

self.mdiArea.addSubWindow(child)

self.mdiArea.currentSubWindow().showMaximized()

if(child.radioclient is not None):

self.mdiArea.addSubWindow(child)

self.mdiArea.currentSubWindow().showMaximized()

def setActiveSubWindow(self, window):

if window:

self.mdiArea.setActiveSubWindow(window)

def createActions(self):

statusTip="Exit the application",

statusTip="Close the active window",

triggered=self.mdiArea.closeActiveSubWindow)

statusTip="Close all the windows",

triggered=self.mdiArea.closeAllSubWindows)

statusTip="Tile the windows",

triggered=self.mdiArea.tileSubWindows,

shortcut=qks)

statusTip="Cascade the windows", shortcut=qks,

triggered=self.mdiArea.cascadeSubWindows)

statusTip="Move the focus to the next window",

triggered=self.mdiArea.activateNextSubWindow)

statusTip="Move the focus to the previous window",

triggered=self.mdiArea.activatePreviousSubWindow)

self.separatorAct.setSeparator(True)

statusTip="Show the application's About box",

triggered=self.about)

statusTip="Show the Qt library's About box",

def createMenus(self):

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

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

You should have received a copy of the GNU General Public License along with GNU Radio; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Boston, MA 02110-1301, USA.'''

def __init__(self, parent=None):

super(ConInfoDialog, self).__init__(parent)

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

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

def accept(self):

def reject(self):

def update(self):

print("update")

self.timer = None

def __init__(self, radioclient, G):

self.layout.addLayout(self.hlayout)

self.G = G

self._statistics_table = {"Instantaneous": "",

"Average": "avg ",

"Variance": "var "}

self.stattype.addItem("Instantaneous")

self.stattype.addItem("Average")

self.stattype.addItem("Variance")

# Create a checkbox to toggle sorting of graphs

self._sort = False

self.checksort.setCheckState(self._sort)

self.checksort.stateChanged.connect(self.checksort_changed)

# set up table

self.sp.set_autoscale_on(True)

# set up tabs

# set up timer

self.timer = QtCore.QTimer()

self.timer.timeout.connect(self.update)

self.timer.start(500)

def table_update(self,data):

for k in data.keys():

weight = data[k]

existing = self.perfTable.findItems(str(k),QtCore.Qt.MatchFixedString)

if(len(existing) == 0):

self.perfTable.setRowCount( i+1)

self.perfTable.setItem( i,0, Qt.QTableWidgetItem(str(k)))

self.perfTable.setItem( i,1, Qt.QTableWidgetItem(str(weight)))

self.perfTable.setHorizontalHeaderLabels( ["Block Name", "Percent Buffer Full"] )

def update(self):

# get buffer fullness for all blocks

(x, self._statistics_table[self._statistic]),

# strip values out of ctrlport response

buffer_fullness = dict(zip(

blockport_fullness["%s:%d"%(blk,port)] = bdata[port]

if(self.perfTable.isVisible()):

else:

if(self._sort):

sorted_fullness = sorted(blockport_fullness.items(),

key=operator.itemgetter(1))

else:

if self._keymap:

sorted_fullness = len(self._keymap)*['',]

if(not self.disp):

self.disp = self.sp.bar(range(0,len(sorted_fullness)),

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

else:

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

for r,w in zip(self.disp, sorted_fullness):

r.set_height(w[1])

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

def update(self):

# get work time for all blocks

(x, self._statistics_table[self._statistic]),

# strip values out of ctrlport response

total_work = sum(map(lambda x: x.value, wrk_knobs.values()))

else:

if(self._sort):

sorted_work = sorted(work_times.items(), key=operator.itemgetter(1))

else:

if self._keymap:

for b in work_times:

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

else:

if(not self.disp):

self.disp = self.sp.bar(range(0,len(sorted_work)),

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

else:

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

for r,w in zip(self.disp, sorted_work):

r.set_height(w[1])

self.f.canvas.draw()

def update(self):

try:

try:

# update current clock type

if(self.clockKey == None):

kl1 = self.radioclient.getRe([".*perfcounter_clock"])

else:

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

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

self.clockSel.setCurrentIndex(self.clockSelIdx)

self.prevent_clock_change = False

print("WARNING: Failed to get current clock setting!")

nodes_stream = self.G_stream.nodes()

nodes_msg = self.G_msg.nodes()

# get current buffer depths of all output buffers

(x, self._statistics_table[self._statistic]),

st = time.time()

buf_knobs = self.radioclient.getKnobs(kl)

# strip values out of ctrlport response

buf_vals = dict(zip(

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

# get work time for all blocks

(x, self._statistics_table[self._statistic]),

st = time.time()

wrk_knobs = self.radioclient.getKnobs(kl)

# strip values out of ctrlport response

total_work = sum(map(lambda x: x.value, wrk_knobs.values()))

for n in nodes_stream:

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

#for e in ne: # iterate over edges from this block

for e in ne: # iterate over edges from this block

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

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

newweight = buf_vals[n][sourceport]

for n in nodes_msg:

for e in ne: # iterate over edges from this block

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

# set updated weights

# draw graph updates

if(self.do_update):

else:

self.updateGraph()

self.parent.statusBar().showMessage("Current GNU Radio Control Port Query Latency: %f ms"%\

(latency*1000))

except Exception as e:

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

# Find window of connection

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

self.close()

else:

sys.exit(1)

return

def rtt(self):

def bpt(self):

def resetPCs(self):

knobs = []

def update_clock(self, clkidx):

if(self.prevent_clock_change):

super(MForm, self).__init__()

if askinfo.exec_():

self.parent = parent

self, statusTip="Runtime Table", triggered=self.rtt)

self.rttBut = Qt.QToolButton()

self, statusTip="Buffer Table", triggered=self.bpt)

self.bptBut = Qt.QToolButton()

statusTip="Reset all Performance Counters",

triggered=self.resetPCs)

self.resetPCsBut = Qt.QToolButton()

statusTip="Pause the Flowgraph",

triggered=self.toggleFlowgraph)

self.pauseFGAct.setCheckable(True)

self.pauseFGBut = Qt.QToolButton()

self._statistic = "Instantaneous"

self._statistics_table = {"Instantaneous": "",

"Average": "avg ",

"Variance": "var "}

self.stattype.addItem("Instantaneous")

self.stattype.addItem("Average")

self.stattype.addItem("Variance")

self.stattype.setMaximumWidth(200)

self.stattype.currentIndexChanged.connect(self.stat_changed)

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

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

msgedgelist = knobs[k].value

elif(blockname not in tmplist):

# only take gr_blocks (no hier_block2)

tmplist.append(blockname)

edges = edgelist.split("\n")[0:-1]

msgedges = msgedgelist.split("\n")[0:-1]

# add stream connections

for e in edges:

_e = e.split("->")

# add msg connections

for e in msgedges:

_e = e.split("->")

for e in n_edges:

self.f = plt.figure(figsize=(10,8), dpi=90)

self.sp.set_autoscale_on(True)

# Indicate to self.update to initialize the graph

self.do_update = False

# generate weights and plot

# set up timer

self.timer = QtCore.QTimer()

self.timer.timeout.connect(self.update)

thrsh = 100

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

i = nearby.index(min(nearby))

#print "MOVING BLOCK: ", self._current_block

#print "CUR POS: ", self.pos.values()[i]

self._grabbed = True

index = self.table.treeWidget.selectedIndexes()

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

itemname = str(item.text(0))

def drawGraph(self):

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,

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

edge_color=self.edge_weights,

edge_cmap=plt.cm.Reds,

ax=self.sp,

arrows=False)

print("\t[ControlPort] edges_list = {0}".format(cp_edges))

print("\t[PerfCounters] on = {0}".format(pcs_on))

print("\t[PerfCounters] export = {0}".format(pcs_exported))

def run(self, client):

MAINWindow(client).show()