from __future__ import print_function

from __future__ import unicode_literals

from gnuradio.ctrlport.RPCConnection import RPCMethods

try:

from gnuradio.ctrlport.RPCConnectionThrift import RPCConnectionThrift

"""

def __init__(self, argv = [], rpcmethod = 'thrift', callback = None, blockingcallback = None):

self.client = None

if rpcmethod in RPCMethods:

if rpcmethod == 'thrift':

#print("making RPCConnectionThrift")

#print("made %s" % self.client)

#print("making callback call")

try:

from gnuradio import qtgui

import sip

except ImportError:

sys.exit(1)

# Setup signals

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

gr.top_block.__init__(self)

self._name = name

self._npts = 500

self._rate = rate

self.knobnames = [name,]

self.setLayout(self.layout)

self.setAcceptDrops(True)

else:

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

self.layout.addWidget(self.py_window)

'Curent Value', 'Units', 'Description']):

# must encapsulate, cuz Qt's bases are not classes

self.uid = uid

self.treeWidget.setColumnCount(len(headers))

self.treeWidget.setGeometry(x,y,xsize,ysize)

self.treeWidget.setHeaderLabels(headers)

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

v = struct.unpack(len(v)*'b', v)

knobprops[k].units, knobprops[k].description])

self.treeWidget.addTopLevelItem(item)

self.transport.open()

def __del__(self):

return self.radio

"""

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

try:

def properties(self, *args):

knobprops = self.thriftclient.radio.properties(*args)

# Boston, MA 02110-1301, USA.

#

import os, sys, time, struct

from gnuradio import gr, ctrlport

from gnuradio.ctrlport.GrDataPlotter import *

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

super(RateDialog, self).__init__(parent)

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

self.delay.setText(str(delay));

self.gridLayout.addWidget(self.delay);

self.gridLayout.addWidget(self.buttonBox);

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

def reject(self):

self.done(0);

def minimumSizeHint(self):

def __init__(self, radioclient):

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.setUnifiedTitleAndToolBarOnMac(True)

self.newCon(radioclient)

self.setWindowIcon(icon)

# Locally turn off ControlPort export from GR. This prevents

child.setWindowTitle(str(child.radioclient))

self.mdiArea.addSubWindow(child)

self.mdiArea.currentSubWindow().showMaximized()

def propertiesMenu(self, key, radio, uid):

title = str(radio)

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

# types and default options.

disp = self.knobprops[uid][key].display

def newUpdaterProxy():

self.newUpdater(key, radio)

def newPlotterRasterBProxy():

self.newPlotRasterB(key, uid, title, pmin, pmax)

menu.setTitle("Item Actions")

menu.setTearOffEnabled(False)

menu.addAction("Plot PSD", newPlotterPsdCProxy)

menu.addAction("Plot Constellation", newPlotterConstProxy)

def newUpdater(self, key, radio):

updater = UpdaterWindow(key, radio, None)

knobprop = self.knobprops[uid][tag]

strr = str(tree.radioclient)

title = strr #title = "{0}:{1}".format(r[3], r[5])

pmin,pmax = get_minmax(knobprop)

disp = knobprop.display

if(disp & gr.DISPTIME):

if(disp & gr.DISPOPTCPLX == 0):

self.newPlotF(tag, uid, title, pmin, pmax,

log, strip, stem)

self.newPlotPsdC(tag, uid, title)

def startDrag(self, e):

mime_data = QtCore.QMimeData()

tag = str(e.text(0))

mime_data.setText(data)

drag.setMimeData(mime_data)

def createPlot(self, plot, uid, title):

plot.start()

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

if(p == q):

#plots.remove(p)

#plots.append(q)

break

for plots in self.plots:

for p in plots:

plots.remove(p)

break

data = []

for n in plot.knobnames:

d = knobs[n].value

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

# Unpack and convert to floats for plotting.

def createActions(self):

statusTip="Create a new file", triggered=self.newCon)

statusTip="Exit the application",

statusTip="Close the active window",

triggered=self.mdiArea.closeActiveSubWindow)

statusTip="Close all the windows",

triggered=self.mdiArea.closeAllSubWindows)

statusTip="Change Update Rate",

triggered=self.updateRateShow)

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.host.setText("localhost");

self.port.setText("43243");

self.gridLayout.addWidget(self.host);

self.gridLayout.addWidget(self.port);

self.done(0);

def __init__(self, key, radio, parent):

self.key = key;

self.radio = radio

self.resize(300,200)

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

info = radio.printProperties(self.props)

self.layout.addWidget(self.infoLabel)

# Test here to make sure that a 'set' function exists

if(has_set is False):

self.buttonlayout.addWidget(self.cancelButton)

self.layout.addLayout(self.buttonlayout)

else: # we have a set function

self.layout.addWidget(self.textInput)

rv = radio.getKnobs([key])

val = rv[key].value

self.textInput.setText(str(val))

self.sv = rv[key]

self.is_num = ((type(self.sv.value)==float) or (type(self.sv.value)==int))

if(self.is_num):

self.sliderlayout.addWidget(self.slider)

self.steps = 10000

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

self.slider.setRange(0, 10000)

self._set_slider_value(self.sv.value)

self.layout.addLayout(self.sliderlayout)

else:

self._set_slider_value = None

self.buttonlayout.addWidget(self.applyButton)

self.buttonlayout.addWidget(self.setButton)

self.buttonlayout.addWidget(self.cancelButton)

self.slider.setValue(self.steps*(val-self.props.min.value)/self.valspan)

def _slide(self):

self.textInput.setText(str(val))

def _apply(self):

self.done(0)

def update(self):

# TODO: revisit this try-except block, figure out what it's doing, and if we need to keep it. at very lease makes debugging dificult

st = time.time();

knobs = self.radioclient.getKnobs([])

ft = time.time();

latency = ft-st;

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

tableitems = knobs.keys()

#UPDATE TABLE:

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

#UPDATE PLOTS

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

super(MForm, self).__init__()

self.radioclient = radioclient

if(dialogprompt or radioclient.getHost() is None or radioclient.getPort() is None):

askinfo = ConInfoDialog(self);

if askinfo.exec_():

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

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

else:

self.uid = uid

self.parent = parent

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

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

self.resize(775,500)

self.timer = QtCore.QTimer()

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

self.horizontalLayout.addWidget(self.table.treeWidget)

# set up timer

self.updateRate = updateRate;

self.timer.start(self.updateRate)

self.table.treeWidget.customContextMenuRequested.connect(self.openMenu)

# Set up double-click to launch default plotter

# Allow drag/drop event from table item to plotter

def openMenu(self, pos):

index = self.table.treeWidget.selectedIndexes()

class MyApp(object):

def __init__(self, args):

from gnuradio.ctrlport.GNURadioControlPortClient import GNURadioControlPortClient

def run(self, client):

MAINWindow(client).show()

# set up timer

self.timer = QtCore.QTimer()

self.timer.start(500)

for i in range(0,len(nodes)):

# set up timer

self.timer = QtCore.QTimer()

self.timer.start(1000)

# Set up mouse callback functions to move blocks around.

def start(self):

print("monitor::endpoints() = %s" % (gr.rpcmanager_get().endpoints()))

try:

print("running: %s"%(str(cmd)))

self.proc = subprocess.Popen(cmd);

self.started = True