+

+if(ENABLE_GR_CTRLPORT)

+add_subdirectory(ctrlport)

+endif(ENABLE_GR_CTRLPORT)

+"""

+GNU Radio is a free & open-source software development toolkit that provides signal processing blocks to implement software radios. It can be used with readily-available low-cost external RF hardware to create software-defined radios, or without hardware in a simulation-like environment. It is widely used in hobbyist, academic and commercial environments to support both wireless communications research and real-world radio systems.

+

+GNU Radio applications are primarily written using the Python programming language, while the supplied performance-critical signal-processing path is implemented in C++ using processor floating-point extensions, where available. Thus, the developer is able to implement real-time, high-throughput radio systems in a simple-to-use, rapid-application-development environment.

+

+While not primarily a simulation tool, GNU Radio does support development of signal processing algorithms using pre-recorded or generated data, avoiding the need for actual RF hardware.

+

+GNU Radio is licensed under the GNU General Public License (GPL) version 3. All of the code is copyright of the Free Software Foundation.

+"""

+

+# This file makes gnuradio a package

+# The docstring will be associated with the top level of the package.

+# Copyright 2012 Free Software Foundation, Inc.

+#

+# This file is part of GNU Radio

+#

+# 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.

+#

+# 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.

+#

+# 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.

+

+########################################################################

+include(GrPython)

+

+EXECUTE_PROCESS(

+ COMMAND ${ICE_SLICE2PY} -I${CMAKE_SOURCE_DIR}/gnuradio-core/src/lib/runtime

+ --output-dir=${CMAKE_BINARY_DIR}/gnuradio-core/src/python

+ ${CMAKE_SOURCE_DIR}/gnuradio-core/src/lib/runtime/gnuradio.ice

+)

+

+EXECUTE_PROCESS(

+ COMMAND ${ICE_SLICE2PY} -I${CMAKE_SOURCE_DIR}/gnuradio-core/src/lib/runtime

+ --output-dir=${CMAKE_BINARY_DIR}/gnuradio-core/src/python

+ ${CMAKE_SOURCE_DIR}/gnuradio-core/src/lib/runtime/frontend.ice

+)

+

+GR_PYTHON_INSTALL(

+ FILES

+ ${CMAKE_CURRENT_SOURCE_DIR}/__init__.py

+ ${CMAKE_CURRENT_SOURCE_DIR}/IceRadioClient.py

+ DESTINATION ${GR_PYTHON_DIR}/gnuradio/ctrlport/

+ COMPONENT "core_python"

+)

+

+# We don't want to install these in the root Python directory, but we

+# aren't given a choice based on the way slice2py generates the

+# information.

+GR_PYTHON_INSTALL(

+ FILES

+ ${CMAKE_BINARY_DIR}/gnuradio-core/src/python/gnuradio_ice.py

+ ${CMAKE_BINARY_DIR}/gnuradio-core/src/python/frontend_ice.py

+ DESTINATION ${GR_PYTHON_DIR}

+ COMPONENT "core_python"

+)

+

+GR_PYTHON_INSTALL(

+ FILES

+ ${CMAKE_CURRENT_BINARY_DIR}/GNURadio/__init__.py

+ DESTINATION ${GR_PYTHON_DIR}/gnuradio/ctrlport/GNURadio

+ COMPONENT "core_python"

+)

+

+GR_PYTHON_INSTALL(

+ FILES

+ ${CMAKE_CURRENT_BINARY_DIR}/GNURadio/Booter/__init__.py

+ DESTINATION ${GR_PYTHON_DIR}/gnuradio/ctrlport/GNURadio/Booter

+ COMPONENT "core_python"

+)

+

+GR_PYTHON_INSTALL(

+ FILES

+ ${CMAKE_CURRENT_BINARY_DIR}/GNURadio/Frontend/__init__.py

+ DESTINATION ${GR_PYTHON_DIR}/gnuradio/ctrlport/GNURadio/Frontend

+ COMPONENT "core_python"

+)

+

+install(

+ FILES

+ ${CMAKE_CURRENT_SOURCE_DIR}/icon.png

+ DESTINATION ${GR_PYTHON_DIR}/gnuradio/ctrlport

+ COMPONENT "core_python"

+)

+

+GR_PYTHON_INSTALL(

+ FILES

+ ${CMAKE_CURRENT_SOURCE_DIR}/GrDataPlotter.py

+ ${CMAKE_CURRENT_SOURCE_DIR}/monitor.py

+ DESTINATION ${GR_PYTHON_DIR}/gnuradio/ctrlport/

+ COMPONENT "core_python"

+)

+

+GR_PYTHON_INSTALL(

+ FILES

+ ${CMAKE_CURRENT_SOURCE_DIR}/gr-ctrlport-monitor

+ ${CMAKE_CURRENT_SOURCE_DIR}/gr-ctrlport-curses

+ DESTINATION ${GR_RUNTIME_DIR}

+ PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE

+ COMPONENT "core_python"

+)

+

+########################################################################

+# Handle the unit tests

+########################################################################

+if(ENABLE_GR_CTRLPORT)

+ if(ENABLE_TESTING)

+ include(GrTest)

+ file(GLOB py_qa_test_files "qa_*.py")

+ foreach(py_qa_test_file ${py_qa_test_files})

+ get_filename_component(py_qa_test_name ${py_qa_test_file} NAME_WE)

+ set(GR_TEST_TARGET_DEPS gruel gnuradio-core)

+ GR_ADD_TEST(${py_qa_test_name} ${PYTHON_EXECUTABLE} ${py_qa_test_file})

+ endforeach(py_qa_test_file)

+ endif(ENABLE_TESTING)

+endif(ENABLE_GR_CTRLPORT)

+#!/usr/bin/env python

+#

+# Copyright 2012 Free Software Foundation, Inc.

+#

+# This file is part of GNU Radio

+#

+# 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.

+#

+# 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.

+#

+# 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.

+#

+

+from gnuradio import gr

+import sys, time

+

+try:

+ from gnuradio import qtgui

+ from PyQt4 import QtGui, QtCore

+ import sip

+except ImportError:

+ print "Error: Program requires PyQt4 and gr-qtgui."

+ sys.exit(1)

+

+class GrDataPlotterC(gr.top_block):

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

+ gr.top_block.__init__(self)

+

+ self._name = name

+ self._npts = 500

+ samp_rate = 1.0

+

+ self._last_data = self._npts*[0,]

+ self._data_len = 0

+

+ self.src = gr.vector_source_c([])

+ self.thr = gr.throttle(gr.sizeof_gr_complex, rate)

+ self.snk = qtgui.time_sink_c(self._npts, samp_rate,

+ self._name, 1)

+

+ if(pmin is not None or not pmax is None):

+ self.snk.set_y_axis(pmin, pmax)

+

+ self.connect(self.src, self.thr, (self.snk, 0))

+

+ self.snk.set_line_label(0, "Real")

+ self.snk.set_line_label(1, "Imag")

+

+ self.py_window = sip.wrapinstance(self.snk.pyqwidget(), QtGui.QWidget)

+

+ def __del__(self):

+ pass

+

+ def qwidget(self):

+ return self.py_window

+

+ def name(self):

+ return self._name

+

+ def update(self, data):

+ # Ask GUI if there has been a change in nsamps

+ npts = self.snk.nsamps()

+ if(self._npts != npts):

+

+ # Adjust buffers to accomodate new settings

+ if(npts < self._npts):

+ if(self._data_len < npts):

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

+ else:

+ self._last_data = self._last_data[self._data_len-npts:self._data_len]

+ self._data_len = npts

+ else:

+ self._last_data += (npts - self._npts)*[0,]

+ self._npts = npts

+ self.snk.reset()

+

+ # Update the plot data depending on type

+ if(type(data) == list):

+ data_r = data[0::2]

+ data_i = data[1::2]

+ data = [complex(r,i) for r,i in zip(data_r, data_i)]

+ if(len(data) > self._npts):

+ self.src.set_data(data)

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

+ else:

+ newdata = self._last_data[-(self._npts-len(data)):]

+ newdata += data

+ self.src.set_data(newdata)

+ self._last_data = newdata

+

+ else: # single value update

+ if(self._data_len < self._npts):

+ self._last_data[self._data_len] = data

+ self._data_len += 1

+ else:

+ self._last_data = self._last_data[1:]

+ self._last_data.append(data)

+ self.src.set_data(self._last_data)

+

+class GrDataPlotterF(gr.top_block):

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

+ gr.top_block.__init__(self)

+

+ self._name = name

+ self._npts = 500

+ samp_rate = 1.0

+

+ self._last_data = self._npts*[0,]

+ self._data_len = 0

+

+ self.src = gr.vector_source_f([])

+ self.thr = gr.throttle(gr.sizeof_float, rate)

+ self.snk = qtgui.time_sink_f(self._npts, samp_rate,

+ self._name, 1)

+

+ if(pmin is not None or not pmax is None):

+ self.snk.set_y_axis(pmin, pmax)

+

+ self.connect(self.src, self.thr, (self.snk, 0))

+

+ self.py_window = sip.wrapinstance(self.snk.pyqwidget(), QtGui.QWidget)

+

+ def __del__(self):

+ pass

+

+ def qwidget(self):

+ return self.py_window

+

+ def name(self):

+ return self._name

+

+ def update(self, data):

+ # Ask GUI if there has been a change in nsamps

+ npts = self.snk.nsamps()

+ if(self._npts != npts):

+

+ # Adjust buffers to accomodate new settings

+ if(npts < self._npts):

+ if(self._data_len < npts):

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

+ else:

+ self._last_data = self._last_data[self._data_len-npts:self._data_len]

+ self._data_len = npts

+ else:

+ self._last_data += (npts - self._npts)*[0,]

+ self._npts = npts

+ self.snk.reset()

+

+ # Update the plot data depending on type

+ if(type(data) == list):

+ if(len(data) > self._npts):

+ self.src.set_data(data)

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

+ else:

+ newdata = self._last_data[-(self._npts-len(data)):]

+ newdata += data

+ self.src.set_data(newdata)

+ self._last_data = newdata

+

+ else: # single value update

+ if(self._data_len < self._npts):

+ self._last_data[self._data_len] = data

+ self._data_len += 1

+ else:

+ self._last_data = self._last_data[1:]

+ self._last_data.append(data)

+ self.src.set_data(self._last_data)

+

+

+class GrDataPlotterConst(gr.top_block):

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

+ gr.top_block.__init__(self)

+

+ self._name = name

+ self._npts = 500

+ samp_rate = 1.0

+

+ self._last_data = self._npts*[0,]

+ self._data_len = 0

+

+ self.src = gr.vector_source_c([])

+ self.thr = gr.throttle(gr.sizeof_gr_complex, rate)

+ self.snk = qtgui.const_sink_c(self._npts,

+ self._name, 1)

+

+ if(pmin is not None or not pmax is None):

+ self.snk.set_x_axis(pmin, pmax)

+ self.snk.set_y_axis(pmin, pmax)

+

+ self.connect(self.src, self.thr, (self.snk, 0))

+

+ self.py_window = sip.wrapinstance(self.snk.pyqwidget(), QtGui.QWidget)

+

+ def __del__(self):

+ pass

+

+ def qwidget(self):

+ return self.py_window

+

+ def name(self):

+ return self._name

+

+ def update(self, data):

+ # Ask GUI if there has been a change in nsamps

+ npts = self.snk.nsamps()

+ if(self._npts != npts):

+

+ # Adjust buffers to accomodate new settings

+ if(npts < self._npts):

+ if(self._data_len < npts):

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

+ else:

+ self._last_data = self._last_data[self._data_len-npts:self._data_len]

+ self._data_len = npts

+ else:

+ self._last_data += (npts - self._npts)*[0,]

+ self._npts = npts

+ self.snk.reset()

+

+ # Update the plot data depending on type

+ if(type(data) == list):

+ data_r = data[0::2]

+ data_i = data[1::2]

+ data = [complex(r,i) for r,i in zip(data_r, data_i)]

+ if(len(data) > self._npts):

+ self.src.set_data(data)

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

+ else:

+ newdata = self._last_data[-(self._npts-len(data)):]

+ newdata += data

+ self.src.set_data(newdata)

+ self._last_data = newdata

+

+ else: # single value update

+ if(self._data_len < self._npts):

+ self._last_data[self._data_len] = data

+ self._data_len += 1

+ else:

+ self._last_data = self._last_data[1:]

+ self._last_data.append(data)

+ self.src.set_data(self._last_data)

+

+

+class GrDataPlotterPsdC(gr.top_block):

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

+ gr.top_block.__init__(self)

+

+ self._name = name

+ self._samp_rate = 1.0

+ self._fftsize = 2048

+ self._wintype = gr.firdes.WIN_BLACKMAN_hARRIS

+ self._fc = 0

+

+ self._last_data = self._fftsize*[0,]

+ self._data_len = 0

+

+ self.src = gr.vector_source_c([])

+ self.thr = gr.throttle(gr.sizeof_gr_complex, rate)

+ self.snk = qtgui.freq_sink_c(self._fftsize, self._wintype,

+ self._fc, self._samp_rate,

+ self._name, 1)

+

+ if(pmin is not None or not pmax is None):

+ self.snk.set_y_axis(pmin, pmax)

+

+ self.connect(self.src, self.thr, (self.snk, 0))

+

+ self.py_window = sip.wrapinstance(self.snk.pyqwidget(), QtGui.QWidget)

+

+ def __del__(self):

+ pass

+

+ def qwidget(self):

+ return self.py_window

+

+ def name(self):

+ return self._name

+

+ def update(self, data):

+ # Ask GUI if there has been a change in nsamps

+ fftsize = self.snk.fft_size()

+ if(self._fftsize != fftsize):

+

+ # Adjust buffers to accomodate new settings

+ if(fftsize < self._fftsize):

+ if(self._data_len < fftsize):

+ self._last_data = self._last_data[0:fftsize]

+ else:

+ self._last_data = self._last_data[self._data_len-fftsize:self._data_len]

+ self._data_len = fftsize

+ else:

+ self._last_data += (fftsize - self._fftsize)*[0,]

+ self._fftsize = fftsize

+ self.snk.reset()

+

+ # Update the plot data depending on type

+ if(type(data) == list):

+ data_r = data[0::2]

+ data_i = data[1::2]

+ data = [complex(r,i) for r,i in zip(data_r, data_i)]

+ if(len(data) > self._fftsize):

+ self.src.set_data(data)

+ self._last_data = data[-self._fftsize:]

+ else:

+ newdata = self._last_data[-(self._fftsize-len(data)):]

+ newdata += data

+ self.src.set_data(newdata)

+ self._last_data = newdata

+

+ else: # single value update

+ if(self._data_len < self._fftsize):

+ self._last_data[self._data_len] = data

+ self._data_len += 1

+ else:

+ self._last_data = self._last_data[1:]

+ self._last_data.append(data)

+ self.src.set_data(self._last_data)

+

+class GrDataPlotterPsdF(gr.top_block):

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

+ gr.top_block.__init__(self)

+

+ self._name = name

+ self._samp_rate = 1.0

+ self._fftsize = 2048

+ self._wintype = gr.firdes.WIN_BLACKMAN_hARRIS

+ self._fc = 0

+

+ self._last_data = self._fftsize*[0,]

+ self._data_len = 0

+

+ self.src = gr.vector_source_f([])

+ self.thr = gr.throttle(gr.sizeof_float, rate)

+ self.snk = qtgui.freq_sink_f(self._fftsize, self._wintype,

+ self._fc, self._samp_rate,

+ self._name, 1)

+

+ if(pmin is not None or not pmax is None):

+ self.snk.set_y_axis(pmin, pmax)

+

+ self.connect(self.src, self.thr, (self.snk, 0))

+

+ self.py_window = sip.wrapinstance(self.snk.pyqwidget(), QtGui.QWidget)

+

+ def __del__(self):

+ pass

+

+ def qwidget(self):

+ return self.py_window

+

+ def name(self):

+ return self._name

+

+ def update(self, data):

+ # Ask GUI if there has been a change in nsamps

+ fftsize = self.snk.fft_size()

+ if(self._fftsize != fftsize):

+

+ # Adjust buffers to accomodate new settings

+ if(fftsize < self._fftsize):

+ if(self._data_len < fftsize):

+ self._last_data = self._last_data[0:fftsize]

+ else:

+ self._last_data = self._last_data[self._data_len-fftsize:self._data_len]

+ self._data_len = fftsize

+ else:

+ self._last_data += (fftsize - self._fftsize)*[0,]

+ self._fftsize = fftsize

+ self.snk.reset()

+

+ # Update the plot data depending on type

+ if(type(data) == list):

+ data_r = data[0::2]

+ data_i = data[1::2]

+ data = [complex(r,i) for r,i in zip(data_r, data_i)]

+ if(len(data) > self._fftsize):

+ self.src.set_data(data)

+ self._last_data = data[-self._fftsize:]

+ else:

+ newdata = self._last_data[-(self._fftsize-len(data)):]

+ newdata += data

+ self.src.set_data(newdata)

+ self._last_data = newdata

+

+ else: # single value update

+ if(self._data_len < self._fftsize):

+ self._last_data[self._data_len] = data

+ self._data_len += 1

+ else:

+ self._last_data = self._last_data[1:]

+ self._last_data.append(data)

+ self.src.set_data(self._last_data)

+

+

+class GrDataPlotterValueTable:

+ def __init__(self, uid, parent, x, y, xsize, ysize,

+ headers=['Statistic Key ( Source Block :: Stat Name ) ',

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

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

+ self.uid = uid

+ self.treeWidget = QtGui.QTreeWidget(parent)

+ self.treeWidget.setColumnCount(len(headers))

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

+ self.treeWidget.setHeaderLabels(headers)

+ self.treeWidget.resizeColumnToContents(0)

+

+ def updateItems(self, knobs, knobprops):

+ items = [];

+ self.treeWidget.clear()

+ for k, v in knobs.iteritems():

+ items.append(QtGui.QTreeWidgetItem([str(k), str(v.value),

+ knobprops[k].units,

+ knobprops[k].description]))

+ self.treeWidget.insertTopLevelItems(0, items)

+#!/usr/bin/env python

+#

+# Copyright 2012 Free Software Foundation, Inc.

+#

+# This file is part of GNU Radio

+#

+# 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.

+#

+# 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.

+#

+# 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.

+#

+

+import Ice, Glacier2

+from PyQt4 import QtGui, QtCore

+import sys, time, Ice

+from gnuradio import gr

+from gnuradio.ctrlport import GNURadio

+

+class IceRadioClient(Ice.Application):

+ def __init__(self, parentClass):

+ self.parentClass = parentClass

+

+ def getRadio(self, host, port):

+ radiostr = "gnuradio -t:tcp -h " + host + " -p " + port + " -t 3000"

+ base = self.communicator().stringToProxy(radiostr).ice_twoway()

+ radio = GNURadio.ControlPortPrx.checkedCast(base)

+

+ if not radio:

+ sys.stderr.write("{0} : invalid proxy.\n".format(args[0]))

+ return None

+

+ return radio

+

+ def run(self,args):

+ if len(args) < 2:

+ print "useage: [glacierinstance glacierhost glacierport] host port"

+ return

+ if len(args) == 8:

+ self.useglacier = True

+ guser = args[1]

+ gpass = args[2]

+ ginst = args[3]

+ ghost = args[4]

+ gport = args[5]

+ host = args[6]

+ port = args[7]

+ else:

+ self.useglacier = False

+ host = args[1]

+ port = args[2]

+

+ if self.useglacier:

+ gstring = ginst + "/router -t:tcp -h " + ghost + " -p " + gport

+ print "GLACIER: {0}".format(gstring)

+

+ setrouter = Glacier2.RouterPrx.checkedCast(self.communicator().stringToProxy(gstring))

+ self.communicator().setDefaultRouter(setrouter)

+ defaultRouter = self.communicator().getDefaultRouter()

+ #defaultRouter = self.communicator().stringToProxy(gstring)

+ if not defaultRouter:

+ print self.appName() + ": no default router set"

+ return 1

+ else:

+ print str(defaultRouter)

+ router = Glacier2.RouterPrx.checkedCast(defaultRouter)

+ if not router:

+ print self.appName() + ": configured router is not a Glacier2 router"

+ return 1

+

+ while True:

+ print "This demo accepts any user-id / password combination."

+ if not guser == '' and not gpass == '':

+ id = guser

+ pw = gpass

+ else:

+ id = raw_input("user id: ")

+ pw = raw_input("password: ")

+

+ try:

+ router.createSession(id, pw)

+ break

+ except Glacier2.PermissionDeniedException, ex:

+ print "permission denied:\n" + ex.reason

+

+ radio = self.getRadio(host, port)

+ if(radio is None):

+ return 1

+

+ app = QtGui.QApplication(sys.argv)

+ ex = self.parentClass(radio, port, self)

+ ex.show();

+ app.exec_()

+# Copyright 2012 Free Software Foundation, Inc.

+#

+#

+#

+#

+# 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.

+# The presence of this file turns this directory into a Python package

+

+import Ice, IcePy

+

+# import swig generated symbols into the ctrlport namespace

+#from ctrlport_swig import *

+from monitor import *

+# import any pure python here

+#import GNURadio

+#!/usr/bin/env python

+#

+# Copyright 2012 Free Software Foundation, Inc.

+#

+# This file is part of GNU Radio

+#

+# 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.

+#

+# 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.

+#

+# 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.

+#

+

+import threading

+import curses

+import os, sys, time

+from optparse import OptionParser

+

+import Ice

+from gnuradio.ctrlport import GNURadio

+

+ENTER = chr(10)

+UP_ARROW = chr(65)

+DOWN_ARROW = chr(66)

+

+class modem_monitor(threading.Thread):

+ def __init__(self, cb_live, cb_exit, interface):

+ threading.Thread.__init__(self)

+ self.cb_live = cb_live

+ self.cb_exit = cb_exit

+

+ self.running = True

+

+ def __del__(self):

+ rx.close()

+

+ def run(self):

+ while self.running:

+ time.sleep(0.5)

+

+ def shutdown(self):

+ self.running = False

+ self.rx.close()

+

+ def cb(self,contents):

+ (op, sep, payload) = contents.partition(":")

+ if(op == "live"):

+ print "live"

+ self.cb_live(payload)

+ elif(op == "exit"):

+ self.cb_exit(payload)

+ else:

+ print "unknown op arrived! garbage on multicast adx?"

+

+class modem_window(threading.Thread):

+ def __init__(self, locator):

+ threading.Thread.__init__(self)

+ self.locator = locator

+

+ # curses init

+ self.win = curses.newwin(30,100,4,4)

+

+ # Ice/GRCP init

+ self.comm = Ice.initialize()

+ proxy = self.comm.stringToProxy(locator)

+ self.radio = GNURadio.ControlPortPrx.checkedCast(proxy)

+ self.updateKnobs()

+

+ # GUI init

+ self.running = True

+ self.ssel = 0

+ self.start()

+ #self.updateGUI()

+

+ # input loop

+ while(self.running):

+ self.getInput()

+

+ # wait for update thread exit

+ self.join()

+

+ def updateKnobs(self):

+ self.knobs = self.radio.get([])

+

+ def getInput(self):

+ a = self.win.getch()

+ if(a <= 256):

+ a = chr(a)

+ if(a == 'q'):

+ self.running = False

+ elif(a == UP_ARROW):

+ self.ssel = max(self.ssel-1, 0)

+ self.updateGUI()

+ elif(a == DOWN_ARROW):

+ self.ssel = max(min(self.ssel+1, len(self.knobs.keys())-1),0)

+ self.updateGUI()

+ self.updateGUI()

+

+ def updateGUI(self):

+ self.win.clear()

+ self.win.border(0)

+ self.win.addstr(1, 2, "Modem Statistics :: %s"%(self.locator))

+ self.win.addstr(2, 2, "---------------------------------------------------")

+

+ maxnb = 0

+ maxk = 0

+ for k in self.knobs.keys():

+ (nb,k) = k.split("::", 2)

+ maxnb = max(maxnb,len(nb))

+ maxk = max(maxk,len(k))

+

+ offset = 3

+ keys = self.knobs.keys()

+ keys.sort()

+ for k in keys:

+ (nb,sk) = k.split("::", 2)

+ v = self.knobs[k].value

+ sv = str(v)

+ if(len(sv) > 20):

+ sv = sv[0:20]

+ props = 0

+ if(self.ssel == offset-3):

+ props = props | curses.A_REVERSE

+ self.win.addstr(offset, 2, "%s %s %s" % \

+ (nb.rjust(maxnb," "), sk.ljust(maxk," "), sv),props)

+ offset = offset + 1

+ self.win.refresh()

+

+ def run(self):

+ while(self.running):

+ self.updateKnobs()

+ self.updateGUI()

+ time.sleep(1)

+

+class monitor_gui:

+ def __init__(self, interfaces, options):

+

+ locator = None

+

+ # Extract options into a locator

+ if(options.host and options.port):

+ locator = "{0} -t:{1} -h {2} -p {3}".format(

+ options.app, options.protocol,

+ options.host, options.port)

+

+ # Set up GUI

+ self.locators = {}

+

+ self.mode = 0 # modem index screen (modal keyboard input)

+ self.lsel = 0 # selected locator

+ self.scr = curses.initscr()

+ self.updateGUI()

+

+ # Kick off initial monitors

+ self.monitors = []

+ for i in interfaces:

+ self.monitors.append( modem_monitor(self.addModem, self.delModem, i) )

+ self.monitors[-1].start()

+

+ if not ((locator == None) or (locator == "")):

+ self.addModem(locator)

+

+ # wait for user input

+ while(True):

+ self.getInput()

+

+ def addModem(self, locator):

+ if(not self.locators.has_key(locator)):

+ self.locators[locator] = {}

+ self.locators[locator]["update_time"] = time.time()

+ self.locators[locator]["status"] = "live"

+

+ self.updateGUI();

+

+ def delModem(self, locator):

+ #if(self.locators.has_key(locator)):

+ if(not self.locators.has_key(locator)):

+ self.locators[locator] = {}

+ self.locators[locator]["update_time"] = time.time()

+ self.locators[locator]["status"] = "exit"

+

+ self.updateGUI()

+

+ def updateGUI(self):

+ if(self.mode == 0): #redraw locators

+ self.scr.clear()

+ self.scr.border(0)

+ self.scr.addstr(1, 2, " GRCP-Curses Modem Monitor :: (A)dd (R)efresh, (Q)uit, ...")

+ for i in range(len(self.locators.keys())):

+ locator = self.locators.keys()[i]

+ lhash = self.locators[locator]

+ #self.scr.addstr(3+i, 5, locator + str(lhash))

+ props = 0

+ if(self.lsel == i):

+ props = props | curses.A_REVERSE

+ self.scr.addstr(3+i, 5, locator + str(lhash), props)

+ self.scr.refresh()

+

+ def connectGUI(self):

+ self.scr.clear()

+ self.scr.addstr(1, 1, "Connect to radio:")

+ locator = self.scr.getstr(200)

+ self.addModem(locator)

+ self.updateGUI()

+

+ def getInput(self):

+ a = self.scr.getch()

+ self.scr.addstr(20, 2, "got key (%d) " % (int(a)))

+ if(a <= 256):

+ a = chr(a)

+ if(a =='r'):

+ self.updateGUI()

+ elif(a == 'q'):

+ self.shutdown()

+ elif(a == 'a'):

+ self.connectGUI()

+ elif(a == UP_ARROW):

+ self.lsel = max(self.lsel-1, 0)

+ self.updateGUI()

+ elif(a == DOWN_ARROW):

+ self.lsel = max(min(self.lsel+1, len(self.locators.keys())-1),0)

+ self.updateGUI()

+ elif(a == ENTER):

+ try:

+ locator = self.locators.keys()[self.lsel]

+ self.mode = 1

+ mwin = modem_window(locator)

+ self.mode = 0

+ # pop up a new modem display ...

+ self.updateGUI()

+ except:

+ pass

+

+ def shutdown(self):

+ curses.endwin()

+ os._exit(0)

+

+if __name__ == "__main__":

+ parser = OptionParser()

+ parser.add_option("-H", "--host", type="string",

+ help="Hostname of ControlPort server.")

+ parser.add_option("-p", "--port", type="int",

+ help="Port number of host's ControlPort endpoint.")

+ parser.add_option("-i", "--interfaces", type="string",

+ action="append", default=["lo"],

+ help="Interfaces to use. [default=%default]")

+ parser.add_option("-P", "--protocol", type="string", default="tcp",

+ help="Type of protocol to use (usually tcp). [default=%default]")

+ parser.add_option("-a", "--app", type="string", default="gnuradio",

+ help="Name of application [default=%default]")

+ (options, args) = parser.parse_args()

+

+ if((options.host == None) ^ (options.port == None)):

+ print "Please set both a hostname and a port number.\n"

+ parser.print_help()

+ sys.exit(1)

+

+ mg = monitor_gui(options.interfaces, options)

+

+#!/usr/bin/env python

+#

+# Copyright 2012 Free Software Foundation, Inc.

+#

+# This file is part of GNU Radio

+#

+# 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.

+#

+# 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.

+#

+# 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.

+#

+

+from gnuradio import gr, ctrlport

+

+from PyQt4 import QtCore,Qt

+import PyQt4.QtGui as QtGui

+import sys, time

+

+import Ice

+from gnuradio.ctrlport.IceRadioClient import *

+from gnuradio.ctrlport.GrDataPlotter import *

+from gnuradio.ctrlport import GNURadio

+

+class MAINWindow(QtGui.QMainWindow):

+ def minimumSizeHint(self):

+ return Qtgui.QSize(800,600)

+

+ def __init__(self, radio, port, interface):

+

+ super(MAINWindow, self).__init__()

+ self.conns = []

+ self.plots = []

+ self.knobprops = []

+ self.interface = interface

+

+ self.mdiArea = QtGui.QMdiArea()

+ 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.windowMapper.mapped[QtGui.QWidget].connect(self.setActiveSubWindow)

+

+ self.createActions()

+ self.createMenus()

+ self.createToolBars()

+ self.createStatusBar()

+ self.updateMenus()

+

+ self.setWindowTitle("GNU Radio Control Port Monitor")

+ self.setUnifiedTitleAndToolBarOnMac(True)

+

+ self.newCon(radio, port)

+ icon = QtGui.QIcon(ctrlport.__path__[0] + "/icon.png" )

+ self.setWindowIcon(icon)

+

+ def newCon(self, radio=None, port=None):

+ child = MForm(radio, port, len(self.conns), self)

+ if(child.radio is not None):

+ child.setWindowTitle(str(child.radio))

+ self.mdiArea.addSubWindow(child)

+ child.showMaximized()

+ self.conns.append(child)

+ self.plots.append([])

+

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

+ r = str(radio).split(" ")

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

+

+ props = radio.properties([key])

+ pmin = props[key].min.value

+ pmax = props[key].max.value

+ if pmin == []:

+ pmin = None

+ else:

+ pmin = 1.1*pmin

+ if pmax == []:

+ pmax = None

+ else:

+ pmax = 1.1*pmax

+

+ def newUpdaterProxy():

+ self.newUpdater(key, radio)

+

+ def newPlotterFProxy():

+ self.newPlotF(key, uid, title, pmin, pmax)

+

+ def newPlotterCProxy():

+ self.newPlotC(key, uid, title, pmin, pmax)

+

+ def newPlotterConstProxy():

+ self.newPlotConst(key, uid, title, pmin, pmax)

+

+ def newPlotterPsdFProxy():

+ self.newPlotPsdF(key, uid, title)

+

+ def newPlotterPsdCProxy():

+ self.newPlotPsdC(key, uid, title)

+

+ menu = QtGui.QMenu(self)

+ menu.setTitle("Item Actions")

+ menu.setTearOffEnabled(False)

+

+ # object properties

+ menu.addAction("Properties", newUpdaterProxy)

+

+ # displays available if not complex

+ menu.addAction("Plot Time", newPlotterFProxy)

+ menu.addAction("Plot PSD", newPlotterPsdFProxy)

+

+ # displays available if complex

+ menu.addAction("Plot Time (cpx)", newPlotterCProxy)

+ menu.addAction("Plot Constellation", newPlotterConstProxy)

+ menu.addAction("Plot PSD cpx", newPlotterPsdCProxy)

+

+ menu.popup(QtGui.QCursor.pos())

+

+ def newUpdater(self, key, radio):

+ updater = UpdaterWindow(key, radio, None)

+ updater.setWindowTitle("Updater: " + key)

+ updater.setModal(False)

+ updater.exec_()

+

+ def newSub(self, e):

+ tag = str(e.text(0))

+ tree = e.treeWidget().parent()

+ uid = tree.uid

+ knobprop = self.knobprops[uid][tag]

+

+ r = str(tree.radio).split(" ")

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

+ pmin = knobprop.min.value

+ pmax = knobprop.max.value

+ if pmin == []:

+ pmin = None

+ else:

+ pmin = 1.1*pmin

+ if pmax == []:

+ pmax = None

+ else:

+ pmax = 1.1*pmax

+

+ if(knobprop.display == GNURadio.DisplayType.DISPXYSCATTER):

+ self.newPlotConst(tag, uid, title, pmin, pmax)

+ elif(knobprop.display == GNURadio.DisplayType.DISPTIMESERIESF):

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

+ elif(knobprop.display == GNURadio.DisplayType.DISPTIMESERIESC):

+ self.newPlotC(tag, uid, title, pmin, pmax)

+

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

+ plot.start()

+ self.plots[uid].append(plot)

+

+ self.mdiArea.addSubWindow(plot.qwidget())

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

+ self.connect(plot.qwidget(),

+ QtCore.SIGNAL('destroyed(QObject*)'),

+ self.destroyPlot)

+ plot.qwidget().show()

+

+

+ def destroyPlot(self, obj):

+ for plots in self.plots:

+ for p in plots:

+ if p.qwidget() == obj:

+ plots.remove(p)

+ break

+

+ def newPlotConst(self, tag, uid, title="", pmin=None, pmax=None):

+ plot = GrDataPlotterConst(tag, 32e6, pmin, pmax)

+ self.createPlot(plot, uid, title)

+

+ def newPlotF(self, tag, uid, title="", pmin=None, pmax=None):

+ plot = GrDataPlotterF(tag, 32e6, pmin, pmax)

+ self.createPlot(plot, uid, title)

+

+ def newPlotC(self, tag, uid, title="", pmin=None, pmax=None):

+ plot = GrDataPlotterC(tag, 32e6, pmin, pmax)

+ self.createPlot(plot, uid, title)

+

+ def newPlotPsdF(self, tag, uid, title="", pmin=None, pmax=None):

+ plot = GrDataPlotterPsdF(tag, 32e6, pmin, pmax)

+ self.createPlot(plot, uid, title)

+

+ def newPlotPsdC(self, tag, uid, title="", pmin=None, pmax=None):

+ plot = GrDataPlotterPsdC(tag, 32e6, pmin, pmax)

+ self.createPlot(plot, uid, title)

+

+ def update(self, knobs, uid):

+ #sys.stderr.write("KNOB KEYS: {0}\n".format(knobs.keys()))

+ for plot in self.plots[uid]:

+ data = knobs[plot.name()].value

+ plot.update(data)

+ plot.stop()

+ plot.wait()

+ plot.start()

+

+ def setActiveSubWindow(self, window):

+ if window:

+ self.mdiArea.setActiveSubWindow(window)

+

+

+ def createActions(self):

+ self.newConAct = QtGui.QAction("&New Connection",

+ self, shortcut=QtGui.QKeySequence.New,

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

+ #self.newAct = QtGui.QAction(QtGui.QIcon(':/images/new.png'), "&New Plot",

+ self.newPlotAct = QtGui.QAction("&New Plot",

+ self,

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

+

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

+ statusTip="Exit the application",

+ triggered=QtGui.qApp.closeAllWindows)

+

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

+ statusTip="Close the active window",

+ triggered=self.mdiArea.closeActiveSubWindow)

+

+ self.closeAllAct = QtGui.QAction("Close &All", self,

+ statusTip="Close all the windows",

+ triggered=self.mdiArea.closeAllSubWindows)

+

+

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

+ self.tileAct = QtGui.QAction("&Tile", self,

+ statusTip="Tile the windows",

+ triggered=self.mdiArea.tileSubWindows,

+ shortcut=qks)

+

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

+ self.cascadeAct = QtGui.QAction("&Cascade", self,

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

+ triggered=self.mdiArea.cascadeSubWindows)

+

+ self.nextAct = QtGui.QAction("Ne&xt", self,

+ shortcut=QtGui.QKeySequence.NextChild,

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

+ triggered=self.mdiArea.activateNextSubWindow)

+

+ self.previousAct = QtGui.QAction("Pre&vious", self,

+ shortcut=QtGui.QKeySequence.PreviousChild,

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

+ triggered=self.mdiArea.activatePreviousSubWindow)

+

+ self.separatorAct = QtGui.QAction(self)

+ self.separatorAct.setSeparator(True)

+

+ self.aboutAct = QtGui.QAction("&About", self,

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

+ triggered=self.about)

+

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

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

+ triggered=QtGui.qApp.aboutQt)

+

+ def createMenus(self):

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

+ self.fileMenu.addAction(self.newConAct)

+ self.fileMenu.addAction(self.newPlotAct)

+ self.fileMenu.addSeparator()

+ self.fileMenu.addAction(self.exitAct)

+

+ self.windowMenu = self.menuBar().addMenu("&Window")

+ self.updateWindowMenu()

+ self.windowMenu.aboutToShow.connect(self.updateWindowMenu)

+

+ self.menuBar().addSeparator()

+

+ self.helpMenu = self.menuBar().addMenu("&Help")

+ self.helpMenu.addAction(self.aboutAct)

+ self.helpMenu.addAction(self.aboutQtAct)

+

+ def createToolBars(self):

+ self.fileToolBar = self.addToolBar("File")

+ self.fileToolBar.addAction(self.newConAct)

+ self.fileToolBar.addAction(self.newPlotAct)

+

+ self.fileToolBar = self.addToolBar("Window")

+ self.fileToolBar.addAction(self.tileAct)

+ self.fileToolBar.addAction(self.cascadeAct)

+

+ def createStatusBar(self):

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

+

+

+ def activeMdiChild(self):

+ activeSubWindow = self.mdiArea.activeSubWindow()

+ if activeSubWindow:

+ return activeSubWindow.widget()

+ return None

+

+ def updateMenus(self):

+ hasMdiChild = (self.activeMdiChild() is not None)

+ self.closeAct.setEnabled(hasMdiChild)

+ self.closeAllAct.setEnabled(hasMdiChild)

+ self.tileAct.setEnabled(hasMdiChild)

+ self.cascadeAct.setEnabled(hasMdiChild)

+ self.nextAct.setEnabled(hasMdiChild)

+ self.previousAct.setEnabled(hasMdiChild)

+ self.separatorAct.setVisible(hasMdiChild)

+

+ def updateWindowMenu(self):

+ self.windowMenu.clear()

+ self.windowMenu.addAction(self.closeAct)

+ self.windowMenu.addAction(self.closeAllAct)

+ self.windowMenu.addSeparator()

+ self.windowMenu.addAction(self.tileAct)

+ self.windowMenu.addAction(self.cascadeAct)

+ self.windowMenu.addSeparator()

+ self.windowMenu.addAction(self.nextAct)

+ self.windowMenu.addAction(self.previousAct)

+ self.windowMenu.addAction(self.separatorAct)

+

+ def about(self):

+ about_info = \

+'''Copyright 2012 Free Software Foundation, Inc.\n

+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

+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.'''

+

+ QtGui.QMessageBox.about(None, "gr-ctrlport-monitor", about_info)

+

+

+class ConInfoDialog(QtGui.QDialog):

+ def __init__(self, parent=None):

+ super(ConInfoDialog, self).__init__(parent)

+

+ self.gridLayout = QtGui.QGridLayout(self)

+

+

+ self.host = QtGui.QLineEdit(self);

+ self.port = QtGui.QLineEdit(self);

+ self.host.setText("localhost");

+ self.port.setText("43243");

+

+ self.buttonBox = QtGui.QDialogButtonBox(QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel)

+

+ self.gridLayout.addWidget(self.host);

+ self.gridLayout.addWidget(self.port);

+ 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 UpdaterWindow(QtGui.QDialog):

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

+ QtGui.QDialog.__init__(self, parent)

+

+ self.key = key;

+ self.radio = radio

+

+ self.resize(300,200)

+ self.layout = QtGui.QVBoxLayout()

+

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

+ info = str(self.props)

+

+ self.infoLabel = QtGui.QLabel(info)

+ self.layout.addWidget(self.infoLabel)

+

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

+ try:

+ a = radio.set(radio.get([key]))

+ has_set = True

+ except Ice.UnknownException:

+ has_set = False

+

+ if(has_set is False):

+ self.cancelButton = QtGui.QPushButton("Ok")

+ self.cancelButton.connect(self.cancelButton, QtCore.SIGNAL('clicked()'), self.reject)

+

+ self.buttonlayout = QtGui.QHBoxLayout()

+ self.buttonlayout.addWidget(self.cancelButton)

+ self.layout.addLayout(self.buttonlayout)

+

+ else: # we have a set function

+ self.textInput = QtGui.QLineEdit()

+ self.layout.addWidget(self.textInput)

+

+ self.applyButton = QtGui.QPushButton("Apply")

+ self.setButton = QtGui.QPushButton("OK")

+ self.cancelButton = QtGui.QPushButton("Cancel")

+

+ rv = radio.get([key])

+ self.textInput.setText(str(rv[key].value))

+ self.sv = rv[key]

+

+ self.applyButton.connect(self.applyButton, QtCore.SIGNAL('clicked()'), self._apply)

+ self.setButton.connect(self.setButton, QtCore.SIGNAL('clicked()'), self._set)

+ self.cancelButton.connect(self.cancelButton, QtCore.SIGNAL('clicked()'), self.reject)

+

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

+ if(self.is_num):

+ self.sliderlayout = QtGui.QHBoxLayout()

+

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

+

+ self.sliderlayout.addWidget(QtGui.QLabel(str(self.props.min.value)))

+ self.sliderlayout.addWidget(self.slider)

+ self.sliderlayout.addWidget(QtGui.QLabel(str(self.props.max.value)))

+

+ 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.connect(self.slider, QtCore.SIGNAL("sliderReleased()"), self._slide)

+

+ self.layout.addLayout(self.sliderlayout)

+

+ self.buttonlayout = QtGui.QHBoxLayout()

+ self.buttonlayout.addWidget(self.applyButton)

+ self.buttonlayout.addWidget(self.setButton)

+ self.buttonlayout.addWidget(self.cancelButton)

+ self.layout.addLayout(self.buttonlayout)

+

+ # set layout and go...

+ self.setLayout(self.layout)

+

+ def _set_slider_value(self, val):

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

+

+ def _slide(self):

+ val = (self.slider.value()*self.valspan + self.props.min.value)/float(self.steps)

+ self.textInput.setText(str(val))

+

+ def _apply(self):

+ if(type(self.sv.value) == str):

+ val = str(self.textInput.text())

+ elif(type(self.sv.value) == int):

+ val = int(round(float(self.textInput.text())))

+ elif(type(self.sv.value) == float):

+ val = float(self.textInput.text())

+ else:

+ sys.stderr.write("set type not supported! ({0})\n".format(type(self.sv.value)))

+ sys.exit(-1)

+

+ self.sv.value = val

+ km = {}

+ km[self.key] = self.sv

+ self.radio.set(km)

+ self._set_slider_value(self.sv.value)

+

+ def _set(self):

+ self._apply()

+ self.done(0)

+

+

+class MForm(QtGui.QWidget):

+ def update(self):

+ try:

+ st = time.time();

+ knobs = self.radio.get([]);

+ ft = time.time();

+ latency = ft-st;

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

+

+ except Exception, e:

+ sys.stderr.write("ctrlport-monitor: radio.get threw exception ({0}).\n".format(e))

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

+ # Find window of connection

+ remove = []

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

+ if self.parent.conns[self.uid] == p.widget():

+ remove.append(p)

+

+ # Find any subplot windows of connection

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

+ for plot in self.parent.plots[self.uid]:

+ if plot.qwidget() == p.widget():

+ remove.append(p)

+

+ # Clean up local references to these

+ self.parent.conns.remove(self.parent.conns[self.uid])

+ self.parent.plots.remove(self.parent.plots[self.uid])

+

+ # Remove subwindows for connection and plots

+ for r in remove:

+ self.parent.mdiArea.removeSubWindow(r)

+

+ # Clean up self

+ self.close()

+ else:

+ sys.exit(1)

+ return

+

+ tableitems = knobs.keys()

+

+ #UPDATE TABLE:

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

+

+ #UPDATE PLOTS

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

+

+

+ def __init__(self, radio=None, port=None, uid=0, parent=None):

+

+ super(MForm, self).__init__()

+

+ if(radio == None or port == None):

+ askinfo = ConInfoDialog(self);

+ if askinfo.exec_():

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

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

+ radio = parent.interface.getRadio(host, port)

+ else:

+ self.radio = None

+ return

+

+ self.uid = uid

+ self.parent = parent

+ self.horizontalLayout = QtGui.QVBoxLayout(self)

+ self.gridLayout = QtGui.QGridLayout()

+

+ self.radio = radio

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

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

+ self.resize(775,500)

+ self.timer = QtCore.QTimer()

+ self.constupdatediv = 0

+ self.tableupdatediv = 0

+ plotsize=250

+

+ # make table

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

+ sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)

+ self.table.treeWidget.setSizePolicy(sizePolicy)

+ self.table.treeWidget.setEditTriggers(QtGui.QAbstractItemView.EditKeyPressed)

+ self.table.treeWidget.setSortingEnabled(True)

+ self.table.treeWidget.setDragEnabled(True)

+

+ # add things to layouts

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

+

+ # set up timer

+ self.connect(self.timer, QtCore.SIGNAL('timeout()'), self.update)

+ self.timer.start(1000)

+

+ # set up context menu ..

+ self.table.treeWidget.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)

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

+

+ # Set up double-click to launch default plotter

+ self.connect(self.table.treeWidget,

+ QtCore.SIGNAL('itemDoubleClicked(QTreeWidgetItem*, int)'),

+ self.parent.newSub);

+

+ def openMenu(self, pos):

+ index = self.table.treeWidget.selectedIndexes()

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

+ itemname = str(item.text(0))

+ self.parent.propertiesMenu(itemname, self.radio, self.uid)

+

+

+class MyClient(IceRadioClient):

+ def __init__(self):

+ IceRadioClient.__init__(self, MAINWindow)

+

+sys.exit(MyClient().main(sys.argv))

+#!/usr/bin/env python

+#

+# Copyright 2012 Free Software Foundation, Inc.

+#

+# This file is part of GNU Radio

+#

+# 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.

+#

+# 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.

+#

+# 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.

+#

+

+import sys, subprocess, re, signal, time, atexit, os

+from gnuradio import gr

+

+class monitor:

+ def __init__(self):

+ print "ControlPort Monitor running."

+ self.started = False

+ atexit.register(self.shutdown)

+

+ def __del__(self):

+ if(self.started):

+ self.stop()

+

+ def start(self):

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

+ try:

+ self.proc = subprocess.Popen(map(lambda a: ["gr-ctrlport-monitor",

+ re.search("\d+\.\d+\.\d+\.\d+",a).group(0),

+ re.search("-p (\d+)",a).group(1)],

+ gr.rpcmanager_get().endpoints())[0])

+ self.started = True

+ except:

+ self.proc = None

+ print "failed to to start ControlPort Monitor on specified port"

+

+ def stop(self):

+ if(self.proc):

+ if(self.proc.returncode == None):

+ print "\tcalling stop on shutdown"

+ self.proc.terminate()

+ else:

+ print "\tno proc to shut down, exiting"

+

+ def shutdown(self):

+ print "ctrlport.monitor received shutdown signal"

+ if(self.started):

+ self.stop()

+#!/usr/bin/env python

+#

+# Copyright 2012 Free Software Foundation, Inc.

+#

+# This file is part of GNU Radio

+#

+# 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.

+#

+# 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.

+#

+# 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.

+#

+

+#

+# This program tests mixed python and c++ ctrlport exports in a single app

+#

+

+import Ice

+import sys, time, random, numpy

+from gnuradio import gr, gr_unittest

+

+from gnuradio.ctrlport import GNURadio

+from gnuradio import ctrlport

+

+def get1():

+ return "success"

+

+def get2():

+ return "failure"

+

+class inc_class:

+ def __init__(self):

+ self.val = 1

+ def pp(self):

+ self.val = self.val+1

+ return self.val

+

+get3 = inc_class()

+

+def get4():

+ random.seed(0)

+ rv = random.random()

+ return rv

+

+def get5():

+ numpy.random.seed(0)

+ samp_t = numpy.random.randn(24)+1j*numpy.random.randn(24);

+ samp_f = numpy.fft.fft(samp_t);

+ log_pow_f = 20*numpy.log10(numpy.abs(samp_f))

+ rv = list(log_pow_f)

+ return rv;

+

+def get6():

+ numpy.random.seed(0)

+ samp_t = numpy.random.randn(1024)+1j*numpy.random.randn(1024);

+ rv = list(samp_t)

+ return rv;

+

+class test_cpp_py_binding(gr_unittest.TestCase):

+

+ def setUp(self):

+ self.tb = gr.top_block()

+

+ def tearDown(self):

+ self.tb = None

+

+ def test_001(self):

+ v1 = gr.RPC_get_string("pyland", "v1", "unit_1_string",

+ "Python Exported String", "", "", "",

+ gr.DISPNULL)

+ v1.activate(get1)

+

+ v2 = gr.RPC_get_string("pyland", "v2", "unit_2_string",

+ "Python Exported String", "", "", "",

+ gr.DISPNULL)

+ v2.activate(get2)

+

+ v3 = gr.RPC_get_int("pyland", "v3", "unit_3_int",

+ "Python Exported Int", 0, 100, 1,

+ gr.DISPNULL)

+ v3.activate(get3.pp)

+

+ v4 = gr.RPC_get_double("pyland", "time", "unit_4_time_double",

+ "Python Exported Double", 0, 1000, 1,

+ gr.DISPNULL)

+ v4.activate(get4)

+

+ v5 = gr.RPC_get_vector_float("pyland", "fvec", "unit_5_float_vector",

+ "Python Exported Float Vector", [], [], [],

+ gr.DISPTIMESERIESC)

+ v5.activate(get5)

+

+ v6 = gr.RPC_get_vector_gr_complex("pyland", "cvec", "unit_6_gr_complex_vector",

+ "Python Exported Complex Vector", [], [], [],

+ gr.DISPXYSCATTER)

+ v6.activate(get6)

+

+ # print some variables locally

+ val = get1()

+ rval = v1.get()

+ self.assertEqual(val, rval)

+

+ val = get2()

+ rval = v2.get()

+ self.assertEqual(val, rval)

+

+ val = get3.pp()

+ rval = v3.get()

+ self.assertEqual(val+1, rval)

+

+ val = get4()

+ rval = v4.get()

+ self.assertEqual(val, rval)

+

+ val = get5()

+ rval = v5.get()

+ self.assertComplexTuplesAlmostEqual(val, rval, 5)

+

+ val = get6()

+ rval = v6.get()

+ self.assertComplexTuplesAlmostEqual(val, rval, 5)

+

+ def test_002(self):

+ data = range(1,9)

+

+ self.src = gr.vector_source_c(data)

+ self.p1 = gr.ctrlport_probe_c("aaa","C++ exported variable")

+ self.p2 = gr.ctrlport_probe_c("bbb","C++ exported variable")

+ probe_name = self.p2.alias()

+

+ self.tb.connect(self.src, self.p1)

+ self.tb.connect(self.src, self.p2)

+ self.tb.start()

+

+ # Probes return complex values as list of floats with re, im

+ # Imaginary parts of this data set are 0.

+ expected_result = [1, 0, 2, 0, 3, 0, 4, 0,

+ 5, 0, 6, 0, 7, 0, 8, 0]

+

+ # Make sure we have time for flowgraph to run

+ time.sleep(0.1)

+

+ # Get available endpoint

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

+

+ # Initialize a simple Ice client from endpoint

+ ic = Ice.initialize(sys.argv)

+ base = ic.stringToProxy(ep)

+ radio = GNURadio.ControlPortPrx.checkedCast(base)

+

+ # Get all exported knobs

+ ret = radio.get([probe_name + "::bbb"])

+ for name in ret.keys():

+ result = ret[name].value

+ self.assertEqual(result, expected_result)

+

+ self.tb.stop()

+

+if __name__ == '__main__':

+ gr_unittest.run(test_cpp_py_binding, "test_cpp_py_binding.xml")

+

+#!/usr/bin/env python

+#

+# Copyright 2012 Free Software Foundation, Inc.

+#

+# This file is part of GNU Radio

+#

+# 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.

+#

+# 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.

+#

+# 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.

+#

+

+#

+# This program tests mixed python and c++ GRCP sets in a single app

+#

+

+import Ice

+import sys, time, random, numpy

+from gnuradio import gr, gr_unittest

+

+from gnuradio.ctrlport import GNURadio

+from gnuradio import ctrlport

+

+class inc_class:

+ def __init__(self,val):

+ self.val = val;

+

+ def _get(self):

+ #print "returning get (val = %s)"%(str(self.val));

+ return self.val;

+

+ def _set(self,val):

+ #print "updating val to %s"%(str(val));

+ self.val = val;

+ return;

+

+getset1 = inc_class(10);

+getset2 = inc_class(100.0);

+getset3 = inc_class("test");

+

+class test_cpp_py_binding_set(gr_unittest.TestCase):

+ def setUp(self):

+ self.tb = gr.top_block()

+

+ def tearDown(self):

+ self.tb = None

+

+ def test_001(self):

+

+ g1 = gr.RPC_get_int("pyland", "v1", "unit_1_int",

+ "Python Exported Int", 0, 100, 10,

+ gr.DISPNULL)

+ g1.activate(getset1._get)

+ s1 = gr.RPC_get_int("pyland", "v1", "unit_1_int",

+ "Python Exported Int", 0, 100, 10,

+ gr.DISPNULL)

+ s1.activate(getset1._set)

+ time.sleep(0.01)

+

+ # test int variables

+ getset1._set(21)

+ val = getset1._get()

+ rval = g1.get()

+ self.assertEqual(val, rval)

+

+ g2 = gr.RPC_get_float("pyland", "v2", "unit_2_float",

+ "Python Exported Float", -100, 1000.0, 100.0,

+ gr.DISPNULL)

+ g2.activate(getset2._get)

+ s2 = gr.RPC_get_float("pyland", "v2", "unit_2_float",

+ "Python Exported Float", -100, 1000.0, 100.0,

+ gr.DISPNULL)

+ s2.activate(getset2._set)

+ time.sleep(0.01)

+

+ # test float variables

+ getset2._set(123.456)

+ val = getset2._get()

+ rval = g2.get()

+ self.assertAlmostEqual(val, rval, 4)

+

+ g3 = gr.RPC_get_string("pyland", "v3", "unit_3_string",

+ "Python Exported String", "", "", "",

+ gr.DISPNULL)

+ g3.activate(getset3._get)

+ s3 = gr.RPC_get_string("pyland", "v3", "unit_3_string",

+ "Python Exported String", "", "", "",

+ gr.DISPNULL)

+ s3.activate(getset3._set)

+ time.sleep(0.01)

+

+ # test string variables

+ getset3._set("third test")

+ val = getset3._get()

+ rval = g3.get()

+ self.assertEqual(val, rval)

+

+

+ def test_002(self):

+ data = range(1, 10)

+

+ self.src = gr.vector_source_c(data, True)

+ self.p = gr.nop(gr.sizeof_gr_complex)

+ self.p.set_ctrlport_test(0);

+ probe_info = self.p.alias()

+

+ self.tb.connect(self.src, self.p)

+

+ # Get available endpoint

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

+

+ # Initialize a simple Ice client from endpoint

+ ic = Ice.initialize(sys.argv)

+ base = ic.stringToProxy(ep)

+ radio = GNURadio.ControlPortPrx.checkedCast(base)

+

+ self.tb.start()

+

+ # Make sure we have time for flowgraph to run

+ time.sleep(0.1)

+

+ # Get all exported knobs

+ key_name_test = probe_info+"::test"

+ ret = radio.get([key_name_test,])

+

+ ret[key_name_test].value = 10

+ radio.set({key_name_test: ret[key_name_test]})

+

+ ret = radio.get([])

+ result_test = ret[key_name_test].value

+ self.assertEqual(result_test, 10)

+

+ self.tb.stop()

+ self.tb.wait()

+

+if __name__ == '__main__':

+ gr_unittest.run(test_cpp_py_binding_set, "test_cpp_py_binding_set.xml")

+

+"""

+Display numbers as strings using engineering notation.

+"""

+ Returns:

+ a 2-tuple (0|1, 0|1)

+"""

+Core contents.

+"""

+

+

+ Subclass this to create a python hierarchical block.

+

+ This is a python wrapper around the C++ hierarchical block implementation.

+ self.primitive_message_port_register_hier_in(pmt.intern(portname));

+ self.primitive_message_port_register_hier_out(pmt.intern(portname));

+ key = pmt.string_to_symbol("example_key")

+ value = pmt.string_to_symbol("example_value")

+ #print pmt.symbol_to_string(tag.key)

+ #print pmt.symbol_to_string(tag.value)

+ self.key = pmt.symbol_to_string(tag.key)

+class vector_to_stream(gr.interp_block):

+ def __init__(self, itemsize, nitems_per_block):

+ gr.interp_block.__init__(

+ self,

+ name = "vector_to_stream",

+ in_sig = [(itemsize, nitems_per_block)],

+ out_sig = [itemsize],

+ interp = nitems_per_block

+ )

+ self.block_size = nitems_per_block

+

+ def work(self, input_items, output_items):

+ n = 0

+ for i in xrange(len(input_items[0])):

+ for j in xrange(self.block_size):

+ output_items[0][n] = input_items[0][i][j]

+ n += 1

+

+ return len(output_items[0])

+

+ v2s = vector_to_stream(numpy.float32, 2)