def _do_connect(self):
ret = False
if self.isConnected():
self.disconnect()
self.pyradio = None
self.pyradio_cls = None
if self.radio_type is None or self.radio_type == "":
self.last_error = "No radio type defined"
elif self.radio_type not in CyberRadioDriver.getSupportedRadios():
self.last_error = "Unsupported radio type: %s" % str(self.radio_type)
else:
self.pyradio_cls = CyberRadioDriver.getRadioClass(self.radio_type)
self.pyradio = CyberRadioDriver.getRadioObject(self.radio_type, \
verbose=self.verbose, \
logFile=self.log_file)
if self.connect_mode == "":
# No connection -- this mode supports class method queries
# only.
pass
elif not self.isConnectionModeSupported(self.connect_mode):
self.last_error = "Unsupported connection mode: %s" % \
self.connect_mode
elif self.connect_mode == "tty":
ret = self.connect(self.connect_mode, self.dev_name, \
self.baud_rate, False, False, False)
if not ret:
self.last_error = "Could not connect to %s radio at %s" % \
(self.getName(), self.dev_name)
elif self.connect_mode in ["tcp", "udp"]:
ret = self.connect(self.connect_mode, self.host_name, \
self.host_port, False, False, False)
if not ret:
self.last_error = "Could not connect to %s radio at %s" % \
(self.getName(), self.host_name)
return ret
def set_dataPort(self, interface, dataPort):
print "set_dataPort(%s, %s)" % (
interface,
dataPort,
)
self.interface = interface
self.dataPort = dataPort
self.destMac, self.destIp = crd.getInterfaceAddresses(interface)
self.sourceIp = ".".join(
self.destIp.split(".")[:-1] + [
str(int(self.destIp.split(".")[-1]) + 10),
])
conf = {
crd.configKeys.CONFIG_IP: {
self.dataPort: {
crd.configKeys.IP_SOURCE: self.sourceIp,
#~ crd.configKeys.IP_DEST: { 0: {cfgKeys.GIGE_SOURCE_PORT:self.wbddcPort,
#~ cfgKeys.GIGE_DEST_PORT:self.wbddcPort,
#~ cfgKeys.GIGE_MAC_ADDR:self.destMac,
#~ cfgKeys.GIGE_IP_ADDR:self.destIp,
#~ },
#~ 1: {cfgKeys.GIGE_SOURCE_PORT:self.nbddcPort,
#~ cfgKeys.GIGE_DEST_PORT:self.nbddcPort,
#~ cfgKeys.GIGE_MAC_ADDR:self.destMac,
#~ cfgKeys.GIGE_IP_ADDR:self.destIp,
#~ },
#~ }
}
}
}
#~ printJson(conf)
self.radio.setConfiguration(conf)
def _set_udp_dest_info(self):
destMac, destIp = CyberRadioDriver.getInterfaceAddresses(self.gig_iface_to_use)
srcIpVec = destIp.split(".")
srcIpVec[-1] = str(int(srcIpVec[-1]) + 100)
srcIp = ".".join(srcIpVec)
configDict = {"ipConfiguration": {"sourceIP": srcIp, "destIP": destIp, "destMAC": destMac}}
# self.CyberRadio_file_like_object_source_0.write("Setting UDP Destination Info Config\n")
# self.CyberRadio_file_like_object_source_0.write("configDict=%s\n" % str(configDict))
self.CyberRadio_NDR_driver_interface_0.setConfiguration(configDict)
def update_radio(
self,
disable=False,
):
print((" update_radio(disable=%s) " % (disable)).center(80, '~'))
if not self.init:
self.ten_gbe_radio = not any(i in self.radio_type
for i in ("304", "470", "472"))
self.radio = crd.getRadioObject(self.radio_type,
verbose=self.verbose,
logFile=self.fileLikeObjectSource)
self.radio.connect(self.radio.getConnectionModeList()[0],
self.radio_hostname, self.radio_port)
self._disable_all_ddcs()
def _get_tengig_iface_info(self):
for zero_index, iface_name in enumerate(self.tengig_iface_list):
self.tengig_iface_info[iface_name] = {}
# NDR651 interface indexes are one-based
self.tengig_iface_info[iface_name]["index"] = zero_index + 1
# Determine destination MAC and IP addresses from interface name
self.tengig_iface_info[iface_name]["destMAC"], \
self.tengig_iface_info[iface_name]["destIP"] = \
CyberRadioDriver.getInterfaceAddresses(iface_name)
# Calculate a source IP address from the destination IP address
srcIpVec = self.tengig_iface_info[iface_name]["destIP"].split(".")
srcIpVec[-1] = str(int(srcIpVec[-1]) + 100)
self.tengig_iface_info[iface_name]["sourceIP"] = ".".join(srcIpVec)
pass
def _set_udp_dest_info(self):
destMac, destIp = CyberRadioDriver.getInterfaceAddresses(self.gig_iface_to_use)
srcIpVec = destIp.split(".")
srcIpVec[-1] = str(int(srcIpVec[-1]) + 100)
srcIp = ".".join(srcIpVec)
configDict = {
"ipConfiguration": {
"sourceIP": srcIp,
"destIP": destIp,
"destMAC": destMac,
},
}
#self.CyberRadio_file_like_object_source_0.write("Setting UDP Destination Info Config\n")
#self.CyberRadio_file_like_object_source_0.write("configDict=%s\n" % str(configDict))
self.CyberRadio_NDR_driver_interface_0.setConfiguration(configDict)
def initRadioConnection(self,):
self.log.debug("initRadioConnection")
self.radioObj = self.radioParam.get("obj",None)
if self.radioObj is None:
self.log.debug("Creating radio object")
self.radioObj = crd.getRadioObject(self.radioParam["type"])
if not self.radioObj.isConnected():
self.log.debug("Connecting to radio...")
if all( self.radioParam.has_key(i) for i in ("host","port") ):
self.radioObj.connect( "tcp", self.radioParam["host"], self.radioParam["port"] )
elif all( self.radioParam.has_key(i) for i in ("device","baudrate") ):
self.radioObj.connect( "tty", self.radioParam["device"], self.radioParam["baudrate"] )
else:
raise Exception("%s :: Can't connect to radio"%(self._name))
if self.radioObj.isConnected():
self.log.info("Connected to radio!")
def _set_radio_configuration(self, ):
print((" _set_radio_configuration ").center(80, '~'))
self.radio = crd.ndr304(verbose=self.radio_verbose)
self.radio.connect("tty", self.radio_device, self.radio_baudrate)
dmac, dip, mask = GetInterfaceAddress(self.radio_interface)
temp = [int(i) for i in dip.split(".")]
temp[-1] += 10
sip = ".".join(str(i) for i in temp)
conf = {
crd.configKeys.CONFIG_IP: {
crd.configKeys.IP_SOURCE: sip,
crd.configKeys.IP_DEST: dip,
crd.configKeys.MAC_DEST: dmac,
},
}
self._set_configuration(conf)
def getDipConf(self,dipIndex):
if self.radioInterface in self.radioObj.getGigEIndexRange():
interfaceList = [self.radioInterface,]
else:
interfaceList = self.radioObj.getGigEIndexRange()
self.log.debug("getDipConf: dipIndex = %d(%d), radioInterface = %r(%r)"%(self.dipIndex,dipIndex,self.radioInterface,interfaceList))
dipConfDict = {}
for radioInterface in interfaceList:
dipConfDict[radioInterface] = {
crd.configKeys.IP_DEST: {
dipIndex: {
crd.configKeys.GIGE_SOURCE_PORT:self.udpPort,
crd.configKeys.GIGE_DEST_PORT:self.udpPort,
},
},
}
if self.localInterface is not None and len(self.localInterface)>0:
dmac, dip = crd.getInterfaceAddresses(self.localInterface)
print( "interface = {0}, dmac = {1}, dip = {2}".format(self.localInterface, dmac, dip,) )
temp = [int(i) for i in dip.split(".")]
temp[-1] = (~temp[-1])&0xff
#~ sip = ".".join(str(i) for i in temp)
for radioInterface in interfaceList:
#~ dipConfDict = {
#~ radioInterface: {
#~ crd.configKeys.IP_SOURCE: sip,
#~ crd.configKeys.IP_DEST: {
#~ dipIndex: {
#~ crd.configKeys.GIGE_SOURCE_PORT:self.udpPort,
#~ crd.configKeys.GIGE_DEST_PORT:self.udpPort,
#~ crd.configKeys.GIGE_MAC_ADDR:dmac,
#~ crd.configKeys.GIGE_IP_ADDR:dip,
#~ },
#~ },
#~ },
#~ }
dipConfDict[radioInterface][crd.configKeys.IP_DEST][dipIndex][crd.configKeys.GIGE_MAC_ADDR] = dmac
dipConfDict[radioInterface][crd.configKeys.IP_DEST][dipIndex][crd.configKeys.GIGE_IP_ADDR] = dip
return dipConfDict
def __init__(self,
basePort=22200,
dataPort=1,
hostnameOrDevice='/dev/ndr47x',
ifname='eth6',
radioType='ndr304',
udpPortOrBaudrate=921600,
verbose=1,
vitaLevel=3,
wbfftRate=8,
wbfftSize=10,
wideband2=0):
gr.top_block.__init__(self, "NDR Demo GUI (QT)")
Qt.QWidget.__init__(self)
self.setWindowTitle("NDR Demo GUI (QT)")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "ndr_qt_demo_gui")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Parameters
##################################################
self.basePort = basePort
self.dataPort = dataPort
self.hostnameOrDevice = hostnameOrDevice
self.ifname = ifname
self.radioType = radioType
self.udpPortOrBaudrate = udpPortOrBaudrate
self.verbose = verbose
self.vitaLevel = vitaLevel
self.wbfftRate = wbfftRate
self.wbfftSize = wbfftSize
self.wideband2 = wideband2
##################################################
# Variables
##################################################
self.radioClass = radioClass = crd.getRadioClass(radioType, )
self.ch2_wb = ch2_wb = bool(
wideband2) or radioType.strip().lower() in ("ndr304", "ndr472")
self.ch2_rateSet = ch2_rateSet = radioClass.getWbddcRateSet(
) if ch2_wb else radioClass.getNbddcRateSet()
self.ch1_rateSet = ch1_rateSet = radioClass.getWbddcRateSet()
self.ch2_rateIndex = ch2_rateIndex = sorted(ch2_rateSet.keys())[0]
self.ch1_rateIndex = ch1_rateIndex = sorted(ch1_rateSet.keys())[0]
self.radioRsp = radioRsp = ""
self.macAndIpList = macAndIpList = crd.getInterfaceAddresses(ifname)
self.ch2_rfAttenRange = ch2_rfAttenRange = [
int(i) for i in radioClass.getTunerAttenuationRange()
] if ch2_wb else [0, 0]
self.ch2_fs = ch2_fs = ch2_rateSet[ch2_rateIndex]
self.ch2_channelList = ch2_channelList = radioClass.getWbddcIndexRange(
)[1::2] if ch2_wb else radioClass.getNbddcIndexRange()
self.ch1_updateRate = ch1_updateRate = wbfftRate
self.ch1_fs = ch1_fs = ch1_rateSet[ch1_rateIndex]
self.ch1_fftSize = ch1_fftSize = int(2**wbfftSize)
self.ch1_channelList = ch1_channelList = radioClass.getWbddcIndexRange(
)[0::2] if ch2_wb else radioClass.getWbddcIndexRange()
self.udpPortList = udpPortList = [basePort, basePort + 1]
self.radioRspDisplay = radioRspDisplay = radioRsp
self.radioCmd = radioCmd = ''
self.logfile = logfile = os.path.join(
"/public", "ndrDemoGui", "ndrCmd.%s.log" %
datetime.datetime.now().strftime("%y%m%d-%H%M%S"))
self.ipAddress = ipAddress = macAndIpList[1]
self.fftColSpan = fftColSpan = 6
self.ch2_updateRate = ch2_updateRate = ch1_updateRate if ch2_wb else 4 * ch1_updateRate
self.ch2_rfFreqRange = ch2_rfFreqRange = [
int(i / 1e6) for i in radioClass.getTunerFrequencyRange()
] if ch2_wb else [0, 0]
self.ch2_rfFreq = ch2_rfFreq = int(
sum(radioClass.getTunerFrequencyRange()) / 2e6) if ch2_wb else 0
self.ch2_rfAtten = ch2_rfAtten = ch2_rfAttenRange[0]
self.ch2_index = ch2_index = ch2_channelList[0]
self.ch2_fsLabel = ch2_fsLabel = "%sHz" % (num_to_str(ch2_fs))
self.ch2_fftSize = ch2_fftSize = ch1_fftSize if ch2_wb else ch1_fftSize / 2
self.ch2_ddcFreq = ch2_ddcFreq = 0
self.ch1_rfFreq = ch1_rfFreq = int(
sum(radioClass.getTunerFrequencyRange()) / 2e6)
self.ch1_rfAtten = ch1_rfAtten = int(
radioClass.getTunerAttenuationRange()[0])
self.ch1_index = ch1_index = ch1_channelList[0]
self.ch1_fsLabel = ch1_fsLabel = "%sHz" % (num_to_str(ch1_fs))
self.ch1_ddcFreq = ch1_ddcFreq = 0
##################################################
# Blocks
##################################################
self._ch2_rfFreq_range = Range(
int(radioClass.getTunerFrequencyRange()[0] / 1e6) if ch2_wb else 0,
int(radioClass.getTunerFrequencyRange()[1] / 1e6) if ch2_wb else 0,
20,
int(sum(radioClass.getTunerFrequencyRange()) /
2e6) if ch2_wb else 0, 200)
self._ch2_rfFreq_win = RangeWidget(self._ch2_rfFreq_range,
self.set_ch2_rfFreq,
'RF Freq (MHz)', "counter_slider",
int)
self.top_grid_layout.addWidget(self._ch2_rfFreq_win, 2, fftColSpan + 0,
1, fftColSpan / 2)
self._ch2_rfAtten_range = Range(ch2_rfAttenRange[0],
ch2_rfAttenRange[1], 1,
ch2_rfAttenRange[0], 200)
self._ch2_rfAtten_win = RangeWidget(self._ch2_rfAtten_range,
self.set_ch2_rfAtten,
'RF Atten (dB)', "counter_slider",
int)
self.top_grid_layout.addWidget(self._ch2_rfAtten_win, 2,
fftColSpan + fftColSpan / 2, 1,
fftColSpan / 2)
self._ch2_rateIndex_options = sorted(ch2_rateSet.keys())
self._ch2_rateIndex_labels = map(str, self._ch2_rateIndex_options)
self._ch2_rateIndex_tool_bar = Qt.QToolBar(self)
self._ch2_rateIndex_tool_bar.addWidget(Qt.QLabel('Rate Index' + ": "))
self._ch2_rateIndex_combo_box = Qt.QComboBox()
self._ch2_rateIndex_tool_bar.addWidget(self._ch2_rateIndex_combo_box)
for label in self._ch2_rateIndex_labels:
self._ch2_rateIndex_combo_box.addItem(label)
self._ch2_rateIndex_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._ch2_rateIndex_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._ch2_rateIndex_options.index(i)))
self._ch2_rateIndex_callback(self.ch2_rateIndex)
self._ch2_rateIndex_combo_box.currentIndexChanged.connect(
lambda i: self.set_ch2_rateIndex(self._ch2_rateIndex_options[i]))
self.top_grid_layout.addWidget(self._ch2_rateIndex_tool_bar, 1,
fftColSpan + 1, 1, 1)
self._ch2_index_options = ch2_channelList
self._ch2_index_labels = map(str, self._ch2_index_options)
self._ch2_index_tool_bar = Qt.QToolBar(self)
self._ch2_index_tool_bar.addWidget(
Qt.QLabel("%sDDC" % ("WB" if ch2_wb else "NB") + ": "))
self._ch2_index_combo_box = Qt.QComboBox()
self._ch2_index_tool_bar.addWidget(self._ch2_index_combo_box)
for label in self._ch2_index_labels:
self._ch2_index_combo_box.addItem(label)
self._ch2_index_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._ch2_index_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._ch2_index_options.index(i)))
self._ch2_index_callback(self.ch2_index)
self._ch2_index_combo_box.currentIndexChanged.connect(
lambda i: self.set_ch2_index(self._ch2_index_options[i]))
self.top_grid_layout.addWidget(self._ch2_index_tool_bar, 1,
fftColSpan + 0, 1, 1)
self._ch2_ddcFreq_range = Range(
(radioClass.getWbddcFrequencyRange()
if ch2_wb else radioClass.getNbddcFrequencyRange())[0] / 1e3,
(radioClass.getWbddcFrequencyRange() if ch2_wb else
radioClass.getNbddcFrequencyRange())[1] / 1e3, 10, 0, 200)
self._ch2_ddcFreq_win = RangeWidget(self._ch2_ddcFreq_range,
self.set_ch2_ddcFreq, 'Freq (kHz)',
"counter_slider", float)
self.top_grid_layout.addWidget(self._ch2_ddcFreq_win, 1,
fftColSpan + fftColSpan / 2, 1,
fftColSpan / 2)
self._ch1_rfFreq_range = Range(
int(radioClass.getTunerFrequencyRange()[0] / 1e6),
int(radioClass.getTunerFrequencyRange()[1] / 1e6), 20,
int(sum(radioClass.getTunerFrequencyRange()) / 2e6), 200)
self._ch1_rfFreq_win = RangeWidget(self._ch1_rfFreq_range,
self.set_ch1_rfFreq,
'RF Freq (MHz)', "counter_slider",
int)
self.top_grid_layout.addWidget(self._ch1_rfFreq_win, 2, 0, 1,
fftColSpan / 2)
self._ch1_rfAtten_range = Range(
int(radioClass.getTunerAttenuationRange()[0]),
int(radioClass.getTunerAttenuationRange()[1]), 1,
int(radioClass.getTunerAttenuationRange()[0]), 200)
self._ch1_rfAtten_win = RangeWidget(self._ch1_rfAtten_range,
self.set_ch1_rfAtten,
'RF Atten (dB)', "counter_slider",
int)
self.top_grid_layout.addWidget(self._ch1_rfAtten_win, 2,
fftColSpan / 2, 1, fftColSpan / 2)
self._ch1_rateIndex_options = sorted(ch1_rateSet.keys())
self._ch1_rateIndex_labels = map(str, self._ch1_rateIndex_options)
self._ch1_rateIndex_tool_bar = Qt.QToolBar(self)
self._ch1_rateIndex_tool_bar.addWidget(Qt.QLabel('Rate Index' + ": "))
self._ch1_rateIndex_combo_box = Qt.QComboBox()
self._ch1_rateIndex_tool_bar.addWidget(self._ch1_rateIndex_combo_box)
for label in self._ch1_rateIndex_labels:
self._ch1_rateIndex_combo_box.addItem(label)
self._ch1_rateIndex_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._ch1_rateIndex_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._ch1_rateIndex_options.index(i)))
self._ch1_rateIndex_callback(self.ch1_rateIndex)
self._ch1_rateIndex_combo_box.currentIndexChanged.connect(
lambda i: self.set_ch1_rateIndex(self._ch1_rateIndex_options[i]))
self.top_grid_layout.addWidget(self._ch1_rateIndex_tool_bar, 1, 1, 1,
1)
self._ch1_index_options = ch1_channelList
self._ch1_index_labels = map(str, self._ch1_index_options)
self._ch1_index_tool_bar = Qt.QToolBar(self)
self._ch1_index_tool_bar.addWidget(Qt.QLabel('WBDDC' + ": "))
self._ch1_index_combo_box = Qt.QComboBox()
self._ch1_index_tool_bar.addWidget(self._ch1_index_combo_box)
for label in self._ch1_index_labels:
self._ch1_index_combo_box.addItem(label)
self._ch1_index_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._ch1_index_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._ch1_index_options.index(i)))
self._ch1_index_callback(self.ch1_index)
self._ch1_index_combo_box.currentIndexChanged.connect(
lambda i: self.set_ch1_index(self._ch1_index_options[i]))
self.top_grid_layout.addWidget(self._ch1_index_tool_bar, 1, 0, 1, 1)
self._ch1_ddcFreq_range = Range(
radioClass.getWbddcFrequencyRange()[0] / 1e3,
radioClass.getWbddcFrequencyRange()[1] / 1e3, 10, 0, 200)
self._ch1_ddcFreq_win = RangeWidget(self._ch1_ddcFreq_range,
self.set_ch1_ddcFreq, 'Freq (kHz)',
"counter_slider", float)
self.top_grid_layout.addWidget(self._ch1_ddcFreq_win, 1,
fftColSpan / 2, 1, fftColSpan / 2)
self.ndrDemoControlBlock = CyberRadio.NDR_demo_control(
radio_type=str(radioType),
radio_hostname=str(hostnameOrDevice),
radio_port=int(udpPortOrBaudrate),
tuner1_index=ch1_index,
tuner1_freq=float(1e6 * ch1_rfFreq),
tuner1_atten=ch1_rfAtten,
tuner2_index=ch2_index if ch2_wb else -1,
tuner2_freq=float(1e6 * ch2_rfFreq),
tuner2_atten=ch2_rfAtten,
ddc1_index=ch1_index,
ddc1_wideband=True,
ddc1_enable=True,
ddc1_vita49_level=vitaLevel,
ddc1_rate_index=ch1_rateIndex,
ddc1_freq=ch1_ddcFreq * 1e3,
ddc1_udp_port=udpPortList[0],
ddc1_rf_source=-1,
ddc1_data_port=dataPort,
ddc2_index=ch2_index,
ddc2_wideband=ch2_wb,
ddc2_enable=True,
ddc2_vita49_level=vitaLevel,
ddc2_rate_index=ch2_rateIndex,
ddc2_freq=1e3 * ch2_ddcFreq,
ddc2_udp_port=udpPortList[1],
ddc2_rf_source=-1 if ch2_wb else ch1_index,
ddc2_data_port=dataPort,
cal_freq=0.0,
interface_dict={dataPort: str(ifname)},
verbose=bool(verbose),
other_args={})
self.ch2_tabs = Qt.QTabWidget()
self.ch2_tabs_widget_0 = Qt.QWidget()
self.ch2_tabs_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.ch2_tabs_widget_0)
self.ch2_tabs_grid_layout_0 = Qt.QGridLayout()
self.ch2_tabs_layout_0.addLayout(self.ch2_tabs_grid_layout_0)
self.ch2_tabs.addTab(self.ch2_tabs_widget_0, 'Spectrum')
self.ch2_tabs_widget_1 = Qt.QWidget()
self.ch2_tabs_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.ch2_tabs_widget_1)
self.ch2_tabs_grid_layout_1 = Qt.QGridLayout()
self.ch2_tabs_layout_1.addLayout(self.ch2_tabs_grid_layout_1)
self.ch2_tabs.addTab(self.ch2_tabs_widget_1, 'Time')
self.top_grid_layout.addWidget(self.ch2_tabs, 0, fftColSpan, 1,
fftColSpan)
self.ch1_tabs = Qt.QTabWidget()
self.ch1_tabs_widget_0 = Qt.QWidget()
self.ch1_tabs_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.ch1_tabs_widget_0)
self.ch1_tabs_grid_layout_0 = Qt.QGridLayout()
self.ch1_tabs_layout_0.addLayout(self.ch1_tabs_grid_layout_0)
self.ch1_tabs.addTab(self.ch1_tabs_widget_0, 'Spectrum')
self.ch1_tabs_widget_1 = Qt.QWidget()
self.ch1_tabs_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.ch1_tabs_widget_1)
self.ch1_tabs_grid_layout_1 = Qt.QGridLayout()
self.ch1_tabs_layout_1.addLayout(self.ch1_tabs_grid_layout_1)
self.ch1_tabs.addTab(self.ch1_tabs_widget_1, 'Waterfall')
self.top_grid_layout.addWidget(self.ch1_tabs, 0, 0, 1, fftColSpan)
self._radioRspDisplay_tool_bar = Qt.QToolBar(self)
self._radioRspDisplay_tool_bar.addWidget(
Qt.QLabel('Command Response' + ": "))
self._radioRspDisplay_line_edit = Qt.QLineEdit(
str(self.radioRspDisplay))
self._radioRspDisplay_tool_bar.addWidget(
self._radioRspDisplay_line_edit)
self._radioRspDisplay_line_edit.returnPressed.connect(
lambda: self.set_radioRspDisplay(
str(str(self._radioRspDisplay_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._radioRspDisplay_tool_bar, 3, 2, 1,
2 * fftColSpan - 2)
def _radioRsp_probe():
while True:
val = self.ndrDemoControlBlock.get_radio_rsp()
try:
self.set_radioRsp(val)
except AttributeError:
pass
time.sleep(1.0 / (10))
_radioRsp_thread = threading.Thread(target=_radioRsp_probe)
_radioRsp_thread.daemon = True
_radioRsp_thread.start()
self._radioCmd_tool_bar = Qt.QToolBar(self)
self._radioCmd_tool_bar.addWidget(Qt.QLabel('Manual Command' + ": "))
self._radioCmd_line_edit = Qt.QLineEdit(str(self.radioCmd))
self._radioCmd_tool_bar.addWidget(self._radioCmd_line_edit)
self._radioCmd_line_edit.returnPressed.connect(
lambda: self.set_radioCmd(
str(str(self._radioCmd_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._radioCmd_tool_bar, 3, 0, 1, 2)
self.qtgui_waterfall_sink_x_0 = qtgui.waterfall_sink_c(
ch1_fftSize, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
ch1_rfFreq * 1e6 + ch1_ddcFreq * 1e3, #fc
ch1_fs, #bw
'Ch 1 (Wideband)', #name
1 #number of inputs
)
self.qtgui_waterfall_sink_x_0.set_update_time(1.0 / ch1_updateRate)
self.qtgui_waterfall_sink_x_0.enable_grid(True)
self.qtgui_waterfall_sink_x_0.enable_axis_labels(True)
if not True:
self.qtgui_waterfall_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_waterfall_sink_x_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
colors = [5, 0, 0, 0, 0, 0, 0, 0, 0, 0]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_waterfall_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_waterfall_sink_x_0.set_line_label(i, labels[i])
self.qtgui_waterfall_sink_x_0.set_color_map(i, colors[i])
self.qtgui_waterfall_sink_x_0.set_line_alpha(i, alphas[i])
self.qtgui_waterfall_sink_x_0.set_intensity_range(-120, 0)
self._qtgui_waterfall_sink_x_0_win = sip.wrapinstance(
self.qtgui_waterfall_sink_x_0.pyqwidget(), Qt.QWidget)
self.ch1_tabs_layout_1.addWidget(self._qtgui_waterfall_sink_x_0_win)
self.qtgui_time_sink_x_0 = qtgui.time_sink_c(
1024, #size
ch2_fs, #samp_rate
"", #name
1 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0.set_y_label('Amplitude', "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0, 0,
0, "")
self.qtgui_time_sink_x_0.enable_autoscale(True)
self.qtgui_time_sink_x_0.enable_grid(True)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
if not False:
self.qtgui_time_sink_x_0.disable_legend()
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "blue"
]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2):
if len(labels[i]) == 0:
if (i % 2 == 0):
self.qtgui_time_sink_x_0.set_line_label(
i, "Re{{Data {0}}}".format(i / 2))
else:
self.qtgui_time_sink_x_0.set_line_label(
i, "Im{{Data {0}}}".format(i / 2))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.ch2_tabs_layout_1.addWidget(self._qtgui_time_sink_x_0_win)
self._ch2_fsLabel_tool_bar = Qt.QToolBar(self)
if None:
self._ch2_fsLabel_formatter = None
else:
self._ch2_fsLabel_formatter = lambda x: x
self._ch2_fsLabel_tool_bar.addWidget(Qt.QLabel('fs' + ": "))
self._ch2_fsLabel_label = Qt.QLabel(
str(self._ch2_fsLabel_formatter(self.ch2_fsLabel)))
self._ch2_fsLabel_tool_bar.addWidget(self._ch2_fsLabel_label)
self.top_grid_layout.addWidget(self._ch2_fsLabel_tool_bar, 1,
fftColSpan + 2, 1, 1)
self.ch2_fftDisplay = qtgui.freq_sink_c(
ch2_fftSize, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
(ch2_rfFreq if ch2_wb else ch1_rfFreq) * 1e6 +
ch2_ddcFreq * 1e3, #fc
ch2_fs, #bw
"Channel 2 (%sband)" % ("Wide" if ch2_wb else "Narrow"), #name
1 #number of inputs
)
self.ch2_fftDisplay.set_update_time(1.0 / ch2_updateRate)
self.ch2_fftDisplay.set_y_axis(-120, 0)
self.ch2_fftDisplay.set_y_label('Relative Gain', 'dB')
self.ch2_fftDisplay.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.ch2_fftDisplay.enable_autoscale(False)
self.ch2_fftDisplay.enable_grid(True)
self.ch2_fftDisplay.set_fft_average(0.2)
self.ch2_fftDisplay.enable_axis_labels(True)
self.ch2_fftDisplay.enable_control_panel(False)
if not False:
self.ch2_fftDisplay.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.ch2_fftDisplay.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"red", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "dark blue"
]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.ch2_fftDisplay.set_line_label(i, "Data {0}".format(i))
else:
self.ch2_fftDisplay.set_line_label(i, labels[i])
self.ch2_fftDisplay.set_line_width(i, widths[i])
self.ch2_fftDisplay.set_line_color(i, colors[i])
self.ch2_fftDisplay.set_line_alpha(i, alphas[i])
self._ch2_fftDisplay_win = sip.wrapinstance(
self.ch2_fftDisplay.pyqwidget(), Qt.QWidget)
self.ch2_tabs_layout_0.addWidget(self._ch2_fftDisplay_win)
self._ch1_fsLabel_tool_bar = Qt.QToolBar(self)
if None:
self._ch1_fsLabel_formatter = None
else:
self._ch1_fsLabel_formatter = lambda x: x
self._ch1_fsLabel_tool_bar.addWidget(Qt.QLabel('fs' + ": "))
self._ch1_fsLabel_label = Qt.QLabel(
str(self._ch1_fsLabel_formatter(self.ch1_fsLabel)))
self._ch1_fsLabel_tool_bar.addWidget(self._ch1_fsLabel_label)
self.top_grid_layout.addWidget(self._ch1_fsLabel_tool_bar, 1, 2, 1, 1)
self.ch1_fftDisplay = qtgui.freq_sink_c(
ch1_fftSize, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
ch1_rfFreq * 1e6 + ch1_ddcFreq * 1e3, #fc
ch1_fs, #bw
'Channel 1 (Wideband)', #name
1 #number of inputs
)
self.ch1_fftDisplay.set_update_time(1.0 / ch1_updateRate)
self.ch1_fftDisplay.set_y_axis(-120, 0)
self.ch1_fftDisplay.set_y_label('Relative Gain', 'dB')
self.ch1_fftDisplay.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.ch1_fftDisplay.enable_autoscale(False)
self.ch1_fftDisplay.enable_grid(True)
self.ch1_fftDisplay.set_fft_average(0.2)
self.ch1_fftDisplay.enable_axis_labels(True)
self.ch1_fftDisplay.enable_control_panel(False)
if not False:
self.ch1_fftDisplay.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.ch1_fftDisplay.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"red", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "dark blue"
]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.ch1_fftDisplay.set_line_label(i, "Data {0}".format(i))
else:
self.ch1_fftDisplay.set_line_label(i, labels[i])
self.ch1_fftDisplay.set_line_width(i, widths[i])
self.ch1_fftDisplay.set_line_color(i, colors[i])
self.ch1_fftDisplay.set_line_alpha(i, alphas[i])
self._ch1_fftDisplay_win = sip.wrapinstance(
self.ch1_fftDisplay.pyqwidget(), Qt.QWidget)
self.ch1_tabs_layout_0.addWidget(self._ch1_fftDisplay_win)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char * 1, logfile,
False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_file_descriptor_sink_0 = blocks.file_descriptor_sink(
gr.sizeof_char * 1, 1)
self.CyberRadio_vita_udp_rx_0_0 = CyberRadio.vita_udp_rx(
macAndIpList[1], udpPortList[1], radioClass.getVitaHeaderSize(),
radioClass.getVitaPayloadSize() / 4,
radioClass.getVitaHeaderSize() +
radioClass.getVitaPayloadSize() + radioClass.getVitaTailSize(),
radioClass.isByteswapped(), False, False, False)
self.CyberRadio_vita_udp_rx_0 = CyberRadio.vita_udp_rx(
macAndIpList[1], udpPortList[0], radioClass.getVitaHeaderSize(),
radioClass.getVitaPayloadSize() / 4,
radioClass.getVitaHeaderSize() +
radioClass.getVitaPayloadSize() + radioClass.getVitaTailSize(),
radioClass.isByteswapped(), False, False, False)
##################################################
# Connections
##################################################
self.connect((self.CyberRadio_vita_udp_rx_0, 0),
(self.ch1_fftDisplay, 0))
self.connect((self.CyberRadio_vita_udp_rx_0, 0),
(self.qtgui_waterfall_sink_x_0, 0))
self.connect((self.CyberRadio_vita_udp_rx_0_0, 0),
(self.ch2_fftDisplay, 0))
self.connect((self.CyberRadio_vita_udp_rx_0_0, 0),
(self.qtgui_time_sink_x_0, 0))
self.connect((self.ndrDemoControlBlock, 0),
(self.blocks_file_descriptor_sink_0, 0))
self.connect((self.ndrDemoControlBlock, 0),
(self.blocks_file_sink_0, 0))
def __init__(self, radioHostname='192.168.0.20', radioType='ndr364'):
gr.top_block.__init__(self, "Freq Msg Strobe Test")
Qt.QWidget.__init__(self)
self.setWindowTitle("Freq Msg Strobe Test")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "frq_strobe_test")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Parameters
##################################################
self.radioHostname = radioHostname
self.radioType = radioType
##################################################
# Variables
##################################################
self.radioObj = radioObj = crd.getRadioObject(radioType, verbose=bool(False), host=radioHostname)
self.wbddcRateSet = wbddcRateSet = dict( [(k,v) for k,v in radioObj.getWbddcRateSet().iteritems() if radioObj.getDdcDataFormat(True).get(k,"iq")!="real"] )
self.configFilePath = configFilePath = os.path.expanduser( os.path.join("~",".%s_demo.cfg"%(radioObj.name.lower(),)) )
self._cfg_wbddcRateIndex_config = ConfigParser.ConfigParser()
self._cfg_wbddcRateIndex_config.read(configFilePath)
try: cfg_wbddcRateIndex = self._cfg_wbddcRateIndex_config.getint('wbddc', 'rate_index')
except: cfg_wbddcRateIndex = sorted(wbddcRateSet.keys())[0]
self.cfg_wbddcRateIndex = cfg_wbddcRateIndex
self._cfg_iirAvgExp_config = ConfigParser.ConfigParser()
self._cfg_iirAvgExp_config.read(configFilePath)
try: cfg_iirAvgExp = self._cfg_iirAvgExp_config.getint('gui', 'iirAvgExp')
except: cfg_iirAvgExp = int(3)
self.cfg_iirAvgExp = cfg_iirAvgExp
self.wbddcRateIndex = wbddcRateIndex = cfg_wbddcRateIndex
self.wbddcBwSet = wbddcBwSet = dict( [(k,v) for k,v in radioObj.getWbddcBwSet().iteritems() if radioObj.getDdcDataFormat(True).get(k,"iq")!="real"] )
self.iirAvgExp = iirAvgExp = cfg_iirAvgExp
self._cfg_tunerIndex_config = ConfigParser.ConfigParser()
self._cfg_tunerIndex_config.read(configFilePath)
try: cfg_tunerIndex = self._cfg_tunerIndex_config.getint('tuner', 'index')
except: cfg_tunerIndex = radioObj.getTunerIndexRange()[0]
self.cfg_tunerIndex = cfg_tunerIndex
self._cfg_tunerAtten_config = ConfigParser.ConfigParser()
self._cfg_tunerAtten_config.read(configFilePath)
try: cfg_tunerAtten = self._cfg_tunerAtten_config.getint('tuner', 'atten')
except: cfg_tunerAtten = int(radioObj.getTunerAttenuationRange()[0])
self.cfg_tunerAtten = cfg_tunerAtten
self._cfg_rfFreqMhz_config = ConfigParser.ConfigParser()
self._cfg_rfFreqMhz_config.read(configFilePath)
try: cfg_rfFreqMhz = self._cfg_rfFreqMhz_config.getint('tuner', 'freq')
except: cfg_rfFreqMhz = int(radioObj.getTunerFrequencyRange()[0]/1e6)
self.cfg_rfFreqMhz = cfg_rfFreqMhz
self._cfg_refLevel_config = ConfigParser.ConfigParser()
self._cfg_refLevel_config.read(configFilePath)
try: cfg_refLevel = self._cfg_refLevel_config.getint('display', 'ref_level')
except: cfg_refLevel = 0
self.cfg_refLevel = cfg_refLevel
self._cfg_dynRange_config = ConfigParser.ConfigParser()
self._cfg_dynRange_config.read(configFilePath)
try: cfg_dynRange = self._cfg_dynRange_config.getint('display', 'dyn_range')
except: cfg_dynRange = 120
self.cfg_dynRange = cfg_dynRange
self.wbSampleRate = wbSampleRate = wbddcRateSet[wbddcRateIndex]
self.wbBw = wbBw = wbddcBwSet[wbddcRateIndex]
self.udpBasePort = udpBasePort = 0xcafe
self.tunerIndex = tunerIndex = cfg_tunerIndex
self.tunerAtten = tunerAtten = cfg_tunerAtten
self.samp_rate = samp_rate = 10e6
self.rfFreqMhz = rfFreqMhz = cfg_rfFreqMhz
self.refLevel = refLevel = cfg_refLevel
self.pauseScan = pauseScan = False
self.iirAlpha = iirAlpha = 2.0**(float(-iirAvgExp))
self.fStep = fStep = 100
self.f2 = f2 = int(radioObj.getTunerFrequencyRange()[1]/1e6)
self.f1 = f1 = 100
self.dynRange = dynRange = cfg_dynRange
self.dwell = dwell = 0.5
##################################################
# Blocks
##################################################
self.wbTabs = Qt.QTabWidget()
self.wbTabs_widget_0 = Qt.QWidget()
self.wbTabs_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.wbTabs_widget_0)
self.wbTabs_grid_layout_0 = Qt.QGridLayout()
self.wbTabs_layout_0.addLayout(self.wbTabs_grid_layout_0)
self.wbTabs.addTab(self.wbTabs_widget_0, 'Spectrum')
self.top_grid_layout.addWidget(self.wbTabs, 1,0,1,3)
self.controlTabs = Qt.QTabWidget()
self.controlTabs_widget_0 = Qt.QWidget()
self.controlTabs_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.controlTabs_widget_0)
self.controlTabs_grid_layout_0 = Qt.QGridLayout()
self.controlTabs_layout_0.addLayout(self.controlTabs_grid_layout_0)
self.controlTabs.addTab(self.controlTabs_widget_0, 'control')
self.top_grid_layout.addWidget(self.controlTabs, 0,0,1,1)
self._wbddcRateIndex_options = sorted(wbddcRateSet.keys())
self._wbddcRateIndex_labels = ["%d: %ssps"%(k,num_to_str(wbddcRateSet[k])) for k in sorted(wbddcRateSet.keys())]
self._wbddcRateIndex_tool_bar = Qt.QToolBar(self)
self._wbddcRateIndex_tool_bar.addWidget(Qt.QLabel('WBDDC Sample Rate'+": "))
self._wbddcRateIndex_combo_box = Qt.QComboBox()
self._wbddcRateIndex_tool_bar.addWidget(self._wbddcRateIndex_combo_box)
for label in self._wbddcRateIndex_labels: self._wbddcRateIndex_combo_box.addItem(label)
self._wbddcRateIndex_callback = lambda i: Qt.QMetaObject.invokeMethod(self._wbddcRateIndex_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._wbddcRateIndex_options.index(i)))
self._wbddcRateIndex_callback(self.wbddcRateIndex)
self._wbddcRateIndex_combo_box.currentIndexChanged.connect(
lambda i: self.set_wbddcRateIndex(self._wbddcRateIndex_options[i]))
self.controlTabs_grid_layout_0.addWidget(self._wbddcRateIndex_tool_bar, 0,1,1,1)
self._tunerIndex_options = radioObj.getTunerIndexRange()
self._tunerIndex_labels = map(str, self._tunerIndex_options)
self._tunerIndex_tool_bar = Qt.QToolBar(self)
self._tunerIndex_tool_bar.addWidget(Qt.QLabel('Tuner Index'+": "))
self._tunerIndex_combo_box = Qt.QComboBox()
self._tunerIndex_tool_bar.addWidget(self._tunerIndex_combo_box)
for label in self._tunerIndex_labels: self._tunerIndex_combo_box.addItem(label)
self._tunerIndex_callback = lambda i: Qt.QMetaObject.invokeMethod(self._tunerIndex_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._tunerIndex_options.index(i)))
self._tunerIndex_callback(self.tunerIndex)
self._tunerIndex_combo_box.currentIndexChanged.connect(
lambda i: self.set_tunerIndex(self._tunerIndex_options[i]))
self.controlTabs_grid_layout_0.addWidget(self._tunerIndex_tool_bar, 0,0,1,1)
self._tunerAtten_range = Range(int(radioObj.getTunerAttenuationRange()[0]), int(radioObj.getTunerAttenuationRange()[1]), int(radioObj.getTunerAttenuationRes()), cfg_tunerAtten, 200)
self._tunerAtten_win = RangeWidget(self._tunerAtten_range, self.set_tunerAtten, 'Tuner Atten (dB)', "counter", int)
self.controlTabs_grid_layout_0.addWidget(self._tunerAtten_win, 0,2,1,1)
self._rfFreqMhz_range = Range(int(radioObj.getTunerFrequencyRange()[0]/1e6), int(radioObj.getTunerFrequencyRange()[1]/1e6), 10, cfg_rfFreqMhz, 200)
self._rfFreqMhz_win = RangeWidget(self._rfFreqMhz_range, self.set_rfFreqMhz, 'Tuner Freq (MHz)', "counter_slider", int)
self.controlTabs_grid_layout_0.addWidget(self._rfFreqMhz_win, 0,3,1,2)
self._refLevel_range = Range(-120, +10, 5, cfg_refLevel, (130/5)+1)
self._refLevel_win = RangeWidget(self._refLevel_range, self.set_refLevel, "Ref.\nLevel\n(dB)", "dial", int)
self.wbTabs_grid_layout_0.addWidget(self._refLevel_win, 0,1,1,1)
self._pauseScan_options = (False, True, )
self._pauseScan_labels = ('Run', 'Pause', )
self._pauseScan_group_box = Qt.QGroupBox('Scan')
self._pauseScan_box = Qt.QHBoxLayout()
class variable_chooser_button_group(Qt.QButtonGroup):
def __init__(self, parent=None):
Qt.QButtonGroup.__init__(self, parent)
@pyqtSlot(int)
def updateButtonChecked(self, button_id):
self.button(button_id).setChecked(True)
self._pauseScan_button_group = variable_chooser_button_group()
self._pauseScan_group_box.setLayout(self._pauseScan_box)
for i, label in enumerate(self._pauseScan_labels):
radio_button = Qt.QRadioButton(label)
self._pauseScan_box.addWidget(radio_button)
self._pauseScan_button_group.addButton(radio_button, i)
self._pauseScan_callback = lambda i: Qt.QMetaObject.invokeMethod(self._pauseScan_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._pauseScan_options.index(i)))
self._pauseScan_callback(self.pauseScan)
self._pauseScan_button_group.buttonClicked[int].connect(
lambda i: self.set_pauseScan(self._pauseScan_options[i]))
self.controlTabs_grid_layout_0.addWidget(self._pauseScan_group_box, 1,0,1,1)
self._fStep_range = Range(1, 1000, 10, 100, 200)
self._fStep_win = RangeWidget(self._fStep_range, self.set_fStep, 'Step (MHz)', "counter", float)
self.controlTabs_grid_layout_0.addWidget(self._fStep_win, 1,3,1,1)
self._f2_range = Range(int(radioObj.getTunerFrequencyRange()[0]/1e6), int(radioObj.getTunerFrequencyRange()[1]/1e6), 10, int(radioObj.getTunerFrequencyRange()[1]/1e6), 200)
self._f2_win = RangeWidget(self._f2_range, self.set_f2, 'f2 (MHz)', "counter", float)
self.controlTabs_grid_layout_0.addWidget(self._f2_win, 1,2,1,1)
self._f1_range = Range(int(radioObj.getTunerFrequencyRange()[0]/1e6), int(radioObj.getTunerFrequencyRange()[1]/1e6), 10, 100, 200)
self._f1_win = RangeWidget(self._f1_range, self.set_f1, 'f1 (MHz)', "counter", float)
self.controlTabs_grid_layout_0.addWidget(self._f1_win, 1,1,1,1)
self._dynRange_range = Range(5, 200, 5, cfg_dynRange, (195/5)+1)
self._dynRange_win = RangeWidget(self._dynRange_range, self.set_dynRange, "Dyn.\nRange\n(dB)", "dial", int)
self.wbTabs_grid_layout_0.addWidget(self._dynRange_win, 1,1,1,1)
self._dwell_range = Range(0.001, 10.0, 0.1, 0.5, 200)
self._dwell_win = RangeWidget(self._dwell_range, self.set_dwell, 'dwell', "counter", float)
self.controlTabs_grid_layout_0.addWidget(self._dwell_win, 1,4,1,1)
self.z_tunerControl = CyberRadio.generic_tuner_control_block(
radioObj,
tunerIndex,
True,
1000,
tunerAtten,
1,
None,
{},
False
)
self.y_ddcControl = CyberRadio.generic_ddc_control_block(
radioObj,
tunerIndex,
True,
True,
wbddcRateIndex,
0,
0,
tunerIndex,
0,
-1,
-1,
'',
udpBasePort,
{},
True
)
self.uhd_usrp_sink_1 = uhd.usrp_sink(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
otw_format='sc8',
channels=range(1),
),
)
self.uhd_usrp_sink_1.set_samp_rate(samp_rate)
self.uhd_usrp_sink_1.set_center_freq(uhd.tune_request_t((rfFreqMhz+1)*1e6, 2*samp_rate), 0)
self.uhd_usrp_sink_1.set_gain(20, 0)
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
4096, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
wbSampleRate, #bw
"", #name
1 #number of inputs
)
self.qtgui_freq_sink_x_0.set_update_time(1.0/32)
self.qtgui_freq_sink_x_0.set_y_axis(refLevel-dynRange, refLevel)
self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB')
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.qtgui_freq_sink_x_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0.enable_grid(True)
self.qtgui_freq_sink_x_0.set_fft_average(0.2)
self.qtgui_freq_sink_x_0.enable_axis_labels(True)
self.qtgui_freq_sink_x_0.enable_control_panel(False)
if not False:
self.qtgui_freq_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '',
'', '', '', '', '']
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "dark blue"]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.wbTabs_grid_layout_0.addWidget(self._qtgui_freq_sink_x_0_win, 0,0,3,1)
self._iirAvgExp_range = Range(0, 8, 1, cfg_iirAvgExp, 200)
self._iirAvgExp_win = RangeWidget(self._iirAvgExp_range, self.set_iirAvgExp, 'Avg.', "dial", int)
self.wbTabs_grid_layout_0.addWidget(self._iirAvgExp_win, 2,1,1,1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, radioObj.getVitaPayloadSize()/4)
self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vcc((0.7, ))
self.blocks_message_debug_1 = blocks.message_debug()
self.analog_sig_source_x_0 = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE, 0.1, 1, 0)
self.analog_frequency_modulator_fc_0 = analog.frequency_modulator_fc(1)
self.CyberRadio_zero_copy_source_0 = CyberRadio.zero_copy_source(
'255.255.255.255', udpBasePort,
1, radioObj.getVitaHeaderSize(), radioObj.getVitaPayloadSize()/4,
radioObj.isByteswapped(), radioObj.isIqSwapped(),
"ip proto 17 and ip dst 255.255.255.255 and udp dst port %d"%(udpBasePort,), True,
)
self.CyberRadio_generic_group_control_block_0 = CyberRadio.generic_group_control_block(
radioObj,
0,
False,
True,
([0,1,2,3,]),
{},
False,
)
self.CyberRadio_freq_msg_strobe_0 = CyberRadio.freq_msg_strobe(
pause = bool(pauseScan),
f1 = f1,
f2 = f2,
step = fStep,
dwell = dwell,
wrap = True,
fManual = rfFreqMhz,
msgUnits = 1.0,
msgRes = 1.0e6,
debug = False,
)
##################################################
# Connections
##################################################
self.msg_connect((self.CyberRadio_freq_msg_strobe_0, 'freq'), (self.uhd_usrp_sink_1, 'command'))
self.msg_connect((self.CyberRadio_freq_msg_strobe_0, 'freq'), (self.z_tunerControl, 'freq'))
self.msg_connect((self.y_ddcControl, 'status'), (self.blocks_message_debug_1, 'print'))
self.msg_connect((self.z_tunerControl, 'freq'), (self.qtgui_freq_sink_x_0, 'freq'))
self.connect((self.CyberRadio_zero_copy_source_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.analog_frequency_modulator_fc_0, 0), (self.blocks_multiply_const_vxx_1, 0))
self.connect((self.analog_sig_source_x_0, 0), (self.analog_frequency_modulator_fc_0, 0))
self.connect((self.blocks_multiply_const_vxx_1, 0), (self.uhd_usrp_sink_1, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.qtgui_freq_sink_x_0, 0))
def __init__(self, dataPort=1, ducIndex=1, ducRateIndex=1, hostname='ndr651', localInterface="eth6", txChannel=1):
gr.top_block.__init__(self, "NDR651 Single Tx/Rx Example")
Qt.QWidget.__init__(self)
self.setWindowTitle("NDR651 Single Tx/Rx Example")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "ndr651_single_trx")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Parameters
##################################################
self.dataPort = dataPort
self.ducIndex = ducIndex
self.ducRateIndex = ducRateIndex
self.hostname = hostname
self.localInterface = localInterface
self.txChannel = txChannel
##################################################
# Variables
##################################################
self.confPath = confPath = os.path.expanduser("~/.ndr651_single_trx.cfg")
self._txFreqCfg_config = ConfigParser.ConfigParser()
self._txFreqCfg_config.read(confPath)
try: txFreqCfg = self._txFreqCfg_config.getfloat('tx', 'freq')
except: txFreqCfg = 1000
self.txFreqCfg = txFreqCfg
self._txAttenCfg_config = ConfigParser.ConfigParser()
self._txAttenCfg_config.read(confPath)
try: txAttenCfg = self._txAttenCfg_config.getint('tx', 'atten')
except: txAttenCfg = 0
self.txAttenCfg = txAttenCfg
self.radioObj = radioObj = crd.getRadioObject("ndr651", verbose=False)
self._ducFreqCfg_config = ConfigParser.ConfigParser()
self._ducFreqCfg_config.read(confPath)
try: ducFreqCfg = self._ducFreqCfg_config.getfloat('duc', 'fre')
except: ducFreqCfg = 0
self.ducFreqCfg = ducFreqCfg
self._ducAttenCfg_config = ConfigParser.ConfigParser()
self._ducAttenCfg_config.read(confPath)
try: ducAttenCfg = self._ducAttenCfg_config.getfloat('duc', 'atten')
except: ducAttenCfg = 0
self.ducAttenCfg = ducAttenCfg
self._cwFreqCfg_config = ConfigParser.ConfigParser()
self._cwFreqCfg_config.read(confPath)
try: cwFreqCfg = self._cwFreqCfg_config.getfloat('cw', 'freq')
except: cwFreqCfg = 1.25
self.cwFreqCfg = cwFreqCfg
self._cwAmpCfg_config = ConfigParser.ConfigParser()
self._cwAmpCfg_config.read(confPath)
try: cwAmpCfg = self._cwAmpCfg_config.getfloat('cw', 'amp1')
except: cwAmpCfg = -1.0
self.cwAmpCfg = cwAmpCfg
self.txFreq = txFreq = txFreqCfg
self.txAtten = txAtten = txAttenCfg
self.radioParam = radioParam = {"type":"ndr651", "host":hostname, "port":8617, "obj":radioObj}
self.ducRateSet = ducRateSet = radioObj.getWbducRateSet()
self.ducFreq = ducFreq = ducFreqCfg
self.ducAtten = ducAtten = ducAttenCfg
self.cwFreq = cwFreq = cwFreqCfg
self.cwAmp = cwAmp = cwAmpCfg
##################################################
# Blocks
##################################################
self._txFreq_range = Range(2, 6000, 40, txFreqCfg, 200)
self._txFreq_win = RangeWidget(self._txFreq_range, self.set_txFreq, 'TX Freq (MHz)', "counter_slider", float)
self.top_layout.addWidget(self._txFreq_win)
self._txAtten_range = Range(0, 15, 1, txAttenCfg, 16)
self._txAtten_win = RangeWidget(self._txAtten_range, self.set_txAtten, 'TX Atten', "counter_slider", int)
self.top_layout.addWidget(self._txAtten_win)
self._ducFreq_range = Range(-25.5, +25.5, 0.5, ducFreqCfg, 4001)
self._ducFreq_win = RangeWidget(self._ducFreq_range, self.set_ducFreq, 'DUC Freq (MHz)', "counter_slider", float)
self.top_layout.addWidget(self._ducFreq_win)
self._ducAtten_range = Range(-20, 60, 1.0, ducAttenCfg, int(60/0.25)+1)
self._ducAtten_win = RangeWidget(self._ducAtten_range, self.set_ducAtten, 'DUC Attenuation', "counter_slider", float)
self.top_layout.addWidget(self._ducAtten_win)
self._cwFreq_range = Range(-40.0, +40.0, 1.25, cwFreqCfg, int((80.0/2.5)+1))
self._cwFreq_win = RangeWidget(self._cwFreq_range, self.set_cwFreq, 'GR CW Freq (% BW)', "counter_slider", float)
self.top_layout.addWidget(self._cwFreq_win)
self._cwAmp_range = Range(-90, +10, 1, cwAmpCfg, 101)
self._cwAmp_win = RangeWidget(self._cwAmp_range, self.set_cwAmp, 'GR CW Amp (dB)', "counter_slider", float)
self.top_layout.addWidget(self._cwAmp_win)
self.new_651_sink = CyberRadio.ndr651_sink(hostname, 1024, True)
self.new_651_sink.setDUCParameters(ducIndex, ducRateIndex, txChannel)
self.new_651_sink.setDUCFreq(ducFreq*1e6)
self.new_651_sink.setDUCAtten(ducAtten)
self.new_651_sink.setEthernetInterface(dataPort, localInterface, ducIndex+65000)
self.new_651_sink.setTxFreq(txFreq)
self.new_651_sink.setTxAtten(txAtten)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 1024)
self.blocks_rotator_cc_0 = blocks.rotator_cc(float(cwFreq)*numpy.pi/50)
self.analog_const_source_x_0 = analog.sig_source_c(0, analog.GR_CONST_WAVE, 0, 0, 10.0**(float(cwAmp)/20))
##################################################
# Connections
##################################################
self.connect((self.analog_const_source_x_0, 0), (self.blocks_rotator_cc_0, 0))
self.connect((self.blocks_rotator_cc_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.new_651_sink, 0))
def set_ifname(self, ifname):
self.ifname = ifname
self.set_macAndIpList(crd.getInterfaceAddresses(self.ifname))
def set_radioType(self, radioType):
self.radioType = radioType
self.set_radioClass(crd.getRadioClass(self.radioType, ))
def __init__(self,
verbose_mode=True,
radio_device_name="/dev/ndr47x",
radio_baud_rate=921600,
gig_iface_to_use="eth0",
coherent_mode=0,
num_tuners=1,
tuner1_param_list=[False, 900e6, 0],
tuner2_param_list=[False, 900e6, 0],
tuner3_param_list=[False, 900e6, 0],
tuner4_param_list=[False, 900e6, 0],
tuner5_param_list=[False, 900e6, 0],
tuner6_param_list=[False, 900e6, 0],
num_wbddcs=1,
wbddc1_param_list=[40001, 0, 0, False, 0e6],
wbddc2_param_list=[40002, 0, 0, False, 0e6],
wbddc3_param_list=[40003, 0, 0, False, 0e6],
wbddc4_param_list=[40004, 0, 0, False, 0e6],
wbddc5_param_list=[40005, 0, 0, False, 0e6],
wbddc6_param_list=[40006, 0, 0, False, 0e6],
tagged=False,
):
gr.hier_block2.__init__(
self, "[CyberRadio] NDR304 Source",
gr.io_signature(0, 0, 0),
gr.io_signaturev((6 if coherent_mode & 0x02 > 0 else num_wbddcs) + 1,
(6 if coherent_mode & 0x02 > 0 else num_wbddcs) + 1,
[gr.sizeof_char*1] +
(6 if coherent_mode & 0x02 > 0 else num_wbddcs) * [gr.sizeof_gr_complex*1]),
)
self.verbose_mode = verbose_mode
self.radio_device_name = radio_device_name
self.radio_baud_rate = radio_baud_rate
self.gig_iface_to_use = gig_iface_to_use
self.coherent_mode = coherent_mode
self.tuners_coherent = (self.coherent_mode & 0x01 > 0)
self.ddcs_coherent = (self.coherent_mode & 0x02 > 0)
self.udp_host_name = CyberRadioDriver.getInterfaceAddresses(self.gig_iface_to_use)[1]
self.num_tuners = num_tuners
self.tuner1_param_list = tuner1_param_list
if not self.tuners_coherent:
self.tuner2_param_list = tuner2_param_list
self.tuner3_param_list = tuner3_param_list
self.tuner4_param_list = tuner4_param_list
self.tuner5_param_list = tuner5_param_list
self.tuner6_param_list = tuner6_param_list
self.num_wbddcs = num_wbddcs
self.wbddc1_param_list = wbddc1_param_list
if not self.ddcs_coherent:
self.wbddc2_param_list = wbddc2_param_list
self.wbddc3_param_list = wbddc3_param_list
self.wbddc4_param_list = wbddc4_param_list
self.wbddc5_param_list = wbddc5_param_list
self.wbddc6_param_list = wbddc6_param_list
self.tagged = tagged
self.CyberRadio_file_like_object_source_0 = CyberRadio.file_like_object_source()
self.connect((self.CyberRadio_file_like_object_source_0, 0), (self, 0))
self.CyberRadio_NDR_driver_interface_0 = CyberRadio.NDR_driver_interface(
radio_type="ndr304",
verbose=verbose_mode,
log_file=self.CyberRadio_file_like_object_source_0,
connect_mode="tty",
dev_name=radio_device_name,
baud_rate=radio_baud_rate,
)
self.vita_tail_size = self.CyberRadio_NDR_driver_interface_0.getVitaTailSize()
self.vita_payload_size = self.CyberRadio_NDR_driver_interface_0.getVitaPayloadSize()
self.vita_header_size = self.CyberRadio_NDR_driver_interface_0.getVitaHeaderSize()
self.iq_swapped = self.CyberRadio_NDR_driver_interface_0.isIqSwapped()
self.byte_swapped = self.CyberRadio_NDR_driver_interface_0.isByteswapped()
self._set_coherent_mode(self.coherent_mode)
self._set_udp_dest_info()
if self.num_tuners >= 1:
self._set_tuner_param_list(1, tuner1_param_list)
if not self.tuners_coherent:
if self.num_tuners >= 2:
self._set_tuner_param_list(2, tuner2_param_list)
if self.num_tuners >= 3:
self._set_tuner_param_list(3, tuner3_param_list)
if self.num_tuners >= 4:
self._set_tuner_param_list(4, tuner4_param_list)
if self.num_tuners >= 5:
self._set_tuner_param_list(5, tuner5_param_list)
if self.num_tuners >= 6:
self._set_tuner_param_list(6, tuner6_param_list)
self.wbddc_sources = {}
if self.num_wbddcs >= 1:
self.CyberRadio_vita_iq_source_wbddc_1 = self._get_configured_wbddc(1, wbddc1_param_list)
if self.ddcs_coherent:
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 0), (self, 1))
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 1), (self, 2))
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 2), (self, 3))
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 3), (self, 4))
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 4), (self, 5))
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 5), (self, 6))
else:
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 0), (self, 1))
self.wbddc_sources[1] = self.CyberRadio_vita_iq_source_wbddc_1
if not self.ddcs_coherent:
if self.num_wbddcs >= 2:
self.CyberRadio_vita_iq_source_wbddc_2 = self._get_configured_wbddc(2, wbddc2_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_2, 0), (self, 2))
self.wbddc_sources[2] = self.CyberRadio_vita_iq_source_wbddc_2
if self.num_wbddcs >= 3:
self.CyberRadio_vita_iq_source_wbddc_3 = self._get_configured_wbddc(3, wbddc3_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_3, 0), (self, 3))
self.wbddc_sources[3] = self.CyberRadio_vita_iq_source_wbddc_3
if self.num_wbddcs >= 4:
self.CyberRadio_vita_iq_source_wbddc_4 = self._get_configured_wbddc(4, wbddc4_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_4, 0), (self, 4))
self.wbddc_sources[4] = self.CyberRadio_vita_iq_source_wbddc_4
if self.num_wbddcs >= 5:
self.CyberRadio_vita_iq_source_wbddc_5 = self._get_configured_wbddc(5, wbddc5_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_5, 0), (self, 5))
self.wbddc_sources[5] = self.CyberRadio_vita_iq_source_wbddc_5
if self.num_wbddcs >= 6:
self.CyberRadio_vita_iq_source_wbddc_6 = self._get_configured_wbddc(6, wbddc6_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_6, 0), (self, 6))
self.wbddc_sources[6] = self.CyberRadio_vita_iq_source_wbddc_6
def deviceSetTuning(self,request, fts, tuner_id):
'''
************************************************************
modify fts, which corresponds to self.frontend_tuner_status[tuner_id]
The bandwidth, center frequency, and sampling rate that the hardware was actually tuned
to needs to populate fts (to make sure that it meets the tolerance requirement. For example,
if the tuned values match the requested values, the code would look like this:
fts.bandwidth = request.bandwidth
fts.center_frequency = request.center_frequency
fts.sample_rate = request.sample_rate
return True if the tuning succeeded, and False if it failed
************************************************************'''
print "deviceSetTuning(): Evaluate whether or not a tuner is added *********"
print "tuner_id=%d"%(tuner_id)
if fts.tuner_type == "RX_DIGITIZER": #Receiver configuration
# check for valid frequency
if (self.freqRange[0] > request.center_frequency) or (self.freqRange[1] < request.center_frequency):
print "Frequency out of range : %s"%(request.center_frequency)
return False
# check for valid bandwidth and tolerance
#FIXME: CRD needs to return a bandwidth set
if request.bandwidth > 0:
if (self.ratesWbddc[-1]*self.bwfactor > request.bandwidth*(1+request.bandwidth_tolerance/100)) or \
(self.ratesWbddc[0]*self.bwfactor < request.bandwidth*(1-request.bandwidth_tolerance/100)):
print "Bandwidth out of range : %s"%(request.bandwidth)
return False
# find closest bandwidth
for index, rate in enumerate(self.ratesWbddc):
if rate*self.bwfactor >= request.bandwidth:
bandwidth = rate*self.bwfactor
samplerate = rate
filter_index = index
else:
break
# check for valid sample rate
elif request.sample_rate > 0:
if (self.ratesWbddc[-1] > request.sample_rate*(1+request.sample_rate_tolerance/100)) or \
(self.ratesWbddc[0] < request.sample_rate*(1-request.sample_rate_tolerance/100)):
print "Samplerate out of range : %s"%(request.sample_rate)
return False
#find closest sample rate
for index, rate in enumerate(self.ratesWbddc):
if rate >= request.sample_rate:
bandwidth = rate*self.bwfactor
samplerate = rate
filter_index = index
else:
break
else: #default to narrowest rate
#FIXME: assume bandwidth is 80% of sample rate
bandwidth = round(self.bwfactor*self.ratesWbddc[-1])
samplerate = self.ratesWbddc[-1]
filter_index = len(self.ratesWbddc)-1
# TODO: need RF frequency resource contention for nbddc, i.e. RF set on first nbddc then offset on second
# TODO: check availability of a DDC
# calculate the coarse and fine tuning
coarse = round(request.center_frequency/self.freqRes)
coarse = coarse*self.freqRes
fine = request.center_frequency-coarse
# program tuner
confdict={cfgKeys.CONFIG_TUNER: {tuner_id+1:{cfgKeys.TUNER_FREQUENCY: coarse}}}
self._log.debug("confdict : %s"%(confdict))
self.radio.setConfiguration(confdict)
# program DDC
# NOTE:for WBDDC there is no fine tuning
ddc_confdict=self.confdict[cfgKeys.CONFIG_DDC][cfgKeys.CONFIG_WBDDC][tuner_id+1]
ddc_confdict[cfgKeys.ENABLE]=1
ddc_confdict[cfgKeys.DDC_DATA_PORT]=1 #FIXME: assign ports
ddc_confdict[cfgKeys.DDC_RATE_INDEX]=filter_index
ddc_confdict[cfgKeys.DDC_STREAM_ID]=41000+tuner_id
ddc_confdict[cfgKeys.DDC_VITA_ENABLE]=1
ddc_confdict[cfgKeys.DDC_UDP_DESTINATION]=tuner_id
confdict={cfgKeys.CONFIG_DDC: { cfgKeys.CONFIG_WBDDC: {tuner_id+1:ddc_confdict}}}
self._log.debug("confdict : %s"%(confdict))
self.radio.setConfiguration(confdict)
# set the frontend tuner status
fts.bandwidth = bandwidth
fts.center_frequency = coarse
fts.sample_rate = samplerate
fts.port = 41000+tuner_id
fts.interface = self.tenGbe1
ethconf=crd.getInterfaceAddresses(fts.interface)
fts.ip_address = ethconf[1]
# create new Sourcevita49 and connect to loopback port
if len(self.SV49) < (tuner_id+1):
# create vita49 source
self.SV49.append(sb.launch("rh.SourceVITA49",execparams={"DEBUG_LEVEL":4}))
#connect loopback port
sport = self.SV49[tuner_id].getPort("dataShort_out")
dport = self.getPort("dataShortLB_in")
sport.connectPort(dport,"lb_conn%d"%(tuner_id))
# create an sri for this stream
self.sris.append(bulkio.sri.create(request.allocation_id))
# configure the SourceVita49 module
self.SV49[tuner_id].attachment_override.enabled=True
#FIXME - need to set 10gbe interface load balanced
self.SV49[tuner_id].interface="eth0"
self.SV49[tuner_id].interface=fts.interface
self.SV49[tuner_id].attachment_override.ip_address=fts.ip_address
self.SV49[tuner_id].attachment_override.port=fts.port
self.SV49[tuner_id].VITA49Processing_override.enable=True
self.SV49[tuner_id].VITA49Processing_override.VRL_frames=True
self.SV49[tuner_id].VITA49Processing_override.vector_size=1024
self.SV49[tuner_id].VITA49Processing_override.vita49_packet_size=4136
self.SV49[tuner_id].VITA49Processing_override.byte_swap=True
self.SV49[tuner_id].streamID=request.allocation_id
# refresh the configuration
self.confdict=self.radio.getConfiguration()
return True
else: #Transmitter configuration
# check for valid frequency
if (self.txfreqRange[0] > request.center_frequency) or (self.txfreqRange[1] < request.center_frequency):
print "Frequency out of range : %s"%(request.center_frequency)
return False
# check for valid bandwidth and tolerance
#TODO: Is bandwidth irrelevant for DUC since set by source?
if request.bandwidth > 0:
if (self.ratesDuc[-1]*self.bwfactor > request.bandwidth*(1+request.bandwidth_tolerance/100)) or \
(self.ratesDuc[0]*self.bwfactor < request.bandwidth*(1-request.bandwidth_tolerance/100)):
print "Bandwidth out of range : %s"%(request.bandwidth)
return False
# find closest bandwidth
for index, rate in enumerate(self.ratesDuc):
if rate*self.bwfactor >= request.bandwidth:
bandwidth = rate*self.bwfactor
samplerate = rate
filter_index = index
else:
break
elif request.sample_rate > 0:
if (self.ratesDuc[-1] > request.sample_rate*(1+request.sample_rate_tolerance/100)) or \
(self.ratesDuc[0] < request.sample_rate*(1-request.sample_rate_tolerance/100)):
print "Samplerate out of range : %s"%(request.sample_rate)
return False
#find closest sample rate
for index, rate in enumerate(self.ratesDuc):
if rate >= request.sample_rate:
bandwidth = rate*self.bwfactor
samplerate = rate
filter_index = index
else:
break
else: #default to narrowest rate
#FIXME: assume bandwidth is 80% of sample rate
bandwidth = round(self.bwfactor*self.ratesDuc[-1])
samplerate = self.ratesDuc[-1]
filter_index = len(self.ratesDuc)-1
# TODO: need RF frequency resource contention for duc
# TODO: check availability of a DUC
# calculate the coarse and fine tuning
coarse = round(request.center_frequency/self.txfreqRes)
coarse = coarse*self.txfreqRes
fine = request.center_frequency-coarse
# program tuner
tx_id = tuner_id - self.numDdc
confdict={cfgKeys.CONFIG_TX: {tx_id+1:{cfgKeys.TX_FREQUENCY: coarse}}}
self._log.debug("confdict : %s"%(confdict))
self.radio.setConfiguration(confdict)
# program DUC
# FIXME: set DUC fine tuning
duc_confdict=self.confdict[cfgKeys.CONFIG_DUC][cfgKeys.CONFIG_WBDUC][tx_id+1]
duc_confdict[cfgKeys.DUC_RATE_INDEX]=filter_index
duc_confdict[cfgKeys.DUC_TX_CHANNELS]=tx_id+1
duc_confdict[cfgKeys.DUC_STREAM_ID]=42000+tx_id
confdict={cfgKeys.CONFIG_DUC: { cfgKeys.CONFIG_WBDUC: {tx_id+1:duc_confdict}}}
self._log.debug("confdict : %s"%(confdict))
#FIXME: CRD is currently broken so have to compose duc command manually
#self.radio.setConfiguration(confdict)
new_value = "duc %d, 1, %d, 0, %d, %d, 0, %d"%(tx_id+1,fine,filter_index,tx_id+1,42000+tx_id)
self.rsp = self.radio.sendCommand("%s\n"%(new_value))
self.cmd = new_value;
# set the frontend tuner status
fts.bandwidth = bandwidth
fts.center_frequency = coarse
fts.sample_rate = samplerate
fts.port = 42000+tx_id
fts.interface = self.tenGbe1
ethconf=crd.getInterfaceAddresses(fts.interface)
ipparts = ethconf[1].split('.')
fts.ip_address=ipparts[0]+'.'+ipparts[1]+'.'+ipparts[2]+'.1'
# create new Sinkvita49 blocks and configure them
# note: the transmitters at the end of the receivers in the list so the first
# transmitter is at id numDDc+1. This code instantiates the components only as needed.
if len(self.Tx_SV49) < (tx_id+1):
self.Tx_SV49.append(sb.launch("rh.SinkVITA49"))
self.Tx_SV49_ports.append(self.Tx_SV49[tx_id].getPort("dataShort_in"))
# configure the SinkVita49 module
self.Tx_SV49[tx_id].network_settings.enabled=True
self.Tx_SV49[tx_id].network_settings.port=fts.port
self.Tx_SV49[tx_id].network_settings.ip_address=fts.ip_address
#FIXME - need to set 10gbe interface load balanced
self.Tx_SV49[tx_id].network_settings.interface=fts.interface
self.Tx_SV49[tx_id].network_settings.use_udp_protocol=True
self.Tx_SV49[tx_id].VITA49Encapsulation.enable_vrl_frames=True
self.Tx_SV49[tx_id].VITA49IFContextPacket.enable2=False
self.Tx_SV49[tx_id].advanced_configuration.force_transmit=True
self.Tx_SV49[tx_id].advanced_configuration.max_payload_size=4096
# refresh the configuration
self.confdict=self.radio.getConfiguration()
return True
def constructor(self):
"""
This is called by the framework immediately after your device registers with the system.
In general, you should add customization here and not in the __init__ constructor. If you have
a custom port implementation you can override the specific implementation here with a statement
similar to the following:
self.some_port = MyPortImplementation()
For a tuner device, the structure frontend_tuner_status needs to match the number
of tuners that this device controls and what kind of device it is.
The options for devices are: TX, RX, RX_DIGITIZER, CHANNELIZER, DDC, RC_DIGITIZER_CHANNELIZER
For example, if this device has 5 physical
tuners, each an RX_DIGITIZER, then the code in the construct function should look like this:
self.setNumChannels(5, "RX_DIGITIZER");
The incoming request for tuning contains a string describing the requested tuner
type. The string for the request must match the string in the tuner status.
"""
# TODO add customization here.
# Redefine the control port
self.port_DigitalTuner_in = frontend.InDigitalTunerPort("DigitalTuner_in",self)
# get the model number for this device and make sure CRD supports it
radioClass = crd.getRadioClass(self.model)
if radioClass is None:
raise Exception("Unknown radio model %t. Available radio types: %s"%(self.model,crd.getSupportedRadios()))
# connect to the radio
self.radio = crd.getRadioObject(self.model)
self.radio.connect("tcp", self.host_or_dev, self.port_or_baud)
if self.radio.isConnected():
print self.radio.getVersionInfo()
else:
raise Exception("Unable to connect to host : %s:%s"%(self.host_or_dev, self.port_or_baud))
# query the number of DDC, DUC, RX, and TX, along with rates and bandwidths
self.numRx = self.radio.getNumTuner()
self.numWbddc = self.radio.getNumWbddc()
self.ratesWbddc = self.radio.getWbddcRateList()
self.numNbddc = self.radio.getNumNbddc()
self.ratesNbddc = self.radio.getNbddcRateList()
self.numTx = self.radio.getNumTransmitters()
self.numDuc = self.radio.getNumWbduc()
self.ratesDuc = self.radio.getWbducRateList()
self.numDdc = self.numWbddc + self.numNbddc
self.numChannels = self.numWbddc + self.numNbddc + self.numDuc
self.bwfactor = 0.8
# get the frequency range and step
self.freqRange = self.radio.getTunerFrequencyRange()
self.freqRes = self.radio.getTunerFrequencyRes()
self.txfreqRange = self.radio.getTransmitterFrequencyRange()
self.txfreqRes = self.radio.getTransmitterFrequencyRes()
# set the number of channels
self.setNumChannels(self.numChannels,"RX_DIGITIZER")
# set the TX channels
for i in range(self.numChannels-self.numDuc, self.numChannels):
self.frontend_tuner_status[i].tuner_type="TX"
# init the frequency
for i in range(0, self.numChannels):
self.frontend_tuner_status[i].center_frequency=1000e6
# set the reference mode
self.radio.setReferenceMode(self.reference)
# set the cal signal
self.addPropertyChangeListener('calf', self.setCALF)
self.radio.setCalibrationFrequency(self.calf)
# command handler
self.addPropertyChangeListener('cmd', self.setCMD)
# attenuation
## TODO: add attenuation control
# create lists to hold the vita49 objects
self.SV49=[]
self.Tx_SV49=[]
self.Tx_SV49_ports=[]
self.sris=[]
# get a copy of the full unit configuration
self.confdict=self.radio.getConfiguration()
# set tuner allocation
print self.frontend_tuner_allocation
self.frontend_tuner_allocation.center_frequency=1000e6
# set of SIP/DIP tables
self.num10gbe = self.radio.getNumGigE()
self.numDIPEntries = self.radio.getNumGigEDipEntries()
for i in range(0,self.num10gbe):
# set the source IP as .1 address corresponding to eth address
if i == 0:
ethconf=crd.getInterfaceAddresses(self.tenGbe1)
else:
ethconf=crd.getInterfaceAddresses(self.tenGbe2)
# set source IP address to x.x.x.1
ipparts = ethconf[1].split('.')
self.confdict[cfgKeys.CONFIG_IP][i+1][cfgKeys.IP_SOURCE]=ipparts[0]+'.'+ipparts[1]+'.'+ipparts[2]+'.1'
# set the destination IP table
for j in range(0,self.numDIPEntries):
# set the destinations in sequence
self.confdict[cfgKeys.CONFIG_IP][i+1][cfgKeys.IP_DEST][j][cfgKeys.GIGE_DEST_PORT]=41000+i*500+j
self.confdict[cfgKeys.CONFIG_IP][i+1][cfgKeys.IP_DEST][j][cfgKeys.GIGE_SOURCE_PORT]=31000+i*500+j
self.confdict[cfgKeys.CONFIG_IP][i+1][cfgKeys.IP_DEST][j][cfgKeys.GIGE_MAC_ADDR]=ethconf[0]
self.confdict[cfgKeys.CONFIG_IP][i+1][cfgKeys.IP_DEST][j][cfgKeys.GIGE_IP_ADDR]=ethconf[1]
# write back the ip configuration
self.radio.setConfiguration(self.confdict)
def __init__(
self,
radioType="ndr804",
hostname="ndr308",
verbose=True,
interface="eth6",
dataPort=1,
tunerFreq=1000,
tunerAtten=0,
tunerFilter=1,
tunerIndex=1,
calFrequency=0,
wbddcEnable=True,
wbddcVitaLevel=3,
wbddcRate=0,
wbddcFormat=1,
wbddcFreq=0.0,
wbddcPort=10100,
wbddcIndex=1,
specRate=1,
nbddcEnable=True,
nbddcVitaLevel=3,
nbddcRate=0.0,
#~ nbddcFormat=0,
nbddcDemodType=0,
nbddcDemodBfo=0,
nbddcDemodDcBlock=0,
nbddcDemodAlcType=0,
nbddcDemodAlcLevel=0,
nbddcDemodSquelchLevel=0,
nbddcDagcType=0,
nbddcDagcLevel=0,
nbddcFreq=0.0,
nbddcPort=10101,
nbddcIndex=46,
otherNbddcEnable=False,
otherNbddcPort=10102,
):
gr.hier_block2.__init__(
self,
"CyberRadio/NDR_demo_control",
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_char * 1),
)
self.fileLikeObjectSource = CyberRadio.file_like_object_source()
self.connect((self.fileLikeObjectSource, 0), (self, 0))
print("radioType = %r (%s)" % (radioType, type(radioType)))
print("hostname = %r (%s)" % (hostname, type(hostname)))
print("verbose = %r (%s)" % (verbose, type(verbose)))
print("interface = %r (%s)" % (interface, type(interface)))
print("dataPort = %r (%s)" % (dataPort, type(dataPort)))
print("tunerFreq = %r (%s)" % (tunerFreq, type(tunerFreq)))
print("tunerAtten = %r (%s)" % (tunerAtten, type(tunerAtten)))
print("tunerIndex = %r (%s)" % (tunerIndex, type(tunerIndex)))
print("calFrequency = %r (%s)" % (calFrequency, type(calFrequency)))
print("wbddcEnable = %r (%s)" % (wbddcEnable, type(wbddcEnable)))
print("wbddcVitaLevel = %r (%s)" %
(wbddcVitaLevel, type(wbddcVitaLevel)))
print("wbddcRate = %r (%s)" % (wbddcRate, type(wbddcRate)))
print("wbddcFormat = %r (%s)" % (wbddcFormat, type(wbddcFormat)))
print("wbddcFreq = %r (%s)" % (wbddcFreq, type(wbddcFreq)))
print("wbddcPort = %r (%s)" % (wbddcPort, type(wbddcPort)))
print("wbddcIndex = %r (%s)" % (wbddcIndex, type(wbddcIndex)))
print("specRate = %r (%s)" % (specRate, type(specRate)))
print("nbddcEnable = %r (%s)" % (nbddcEnable, type(nbddcEnable)))
print("nbddcVitaLevel = %r (%s)" %
(nbddcVitaLevel, type(nbddcVitaLevel)))
print("nbddcRate = %r (%s)" % (nbddcRate, type(nbddcRate)))
print("nbddcFreq = %r (%s)" % (nbddcFreq, type(nbddcFreq)))
print("nbddcPort = %r (%s)" % (nbddcPort, type(nbddcPort)))
print("nbddcIndex = %r (%s)" % (nbddcIndex, type(nbddcIndex)))
print("otherNbddcEnable = %r (%s)" %
(otherNbddcEnable, type(otherNbddcEnable)))
print("otherNbddcPort = %r (%s)" %
(otherNbddcPort, type(otherNbddcPort)))
self.init = True
self.set_radioType(radioType)
self.set_hostname(hostname)
self.set_verbose(verbose)
#~ self.set_interface( interface )
#~ self.set_dataPort( dataPort )
self.set_tunerFreq(tunerFreq)
self.set_tunerAtten(tunerAtten)
self.set_tunerFilter(tunerFilter)
self.set_tunerIndex(tunerIndex)
self.set_calFrequency(calFrequency)
self.set_wbddcEnable(wbddcEnable)
self.set_wbddcVitaLevel(wbddcVitaLevel)
self.set_wbddcRate(wbddcRate)
self.set_wbddcFormat(wbddcFormat)
self.set_wbddcFreq(wbddcFreq)
self.set_wbddcPort(wbddcPort)
self.set_wbddcIndex(wbddcIndex)
self.set_specRate(specRate)
self.set_nbddcEnable(nbddcEnable)
self.set_nbddcVitaLevel(nbddcVitaLevel)
self.set_nbddcRate(nbddcRate)
#~ self.set_nbddcFormat( nbddcFormat )
self.set_nbddcDemodType(nbddcDemodType)
self.set_nbddcDemodBfo(nbddcDemodBfo)
self.set_nbddcDemodDcBlock(nbddcDemodDcBlock)
self.set_nbddcDemodAlcType(nbddcDemodAlcType)
self.set_nbddcDemodAlcLevel(nbddcDemodAlcLevel)
self.set_nbddcDemodSquelchLevel(nbddcDemodSquelchLevel)
self.set_nbddcDagcType(nbddcDagcType)
self.set_nbddcDagcLevel(nbddcDagcLevel)
self.set_nbddcFreq(nbddcFreq)
self.set_nbddcPort(nbddcPort)
self.set_nbddcIndex(nbddcIndex)
self.set_otherNbddcEnable(otherNbddcEnable)
self.set_otherNbddcPort(otherNbddcPort)
self.init = False
self.radio = crd.getRadioObject(
self.radioType,
verbose=self.verbose,
logFile=self.fileLikeObjectSource,
)
self.radio.connect("tcp", self.hostname, 8617)
self.set_dataPort(interface, dataPort)
for dipIndex, udpPort in (
(self.wbddcDipIndex, self.wbddcPort),
(self.nbddcDipIndex, self.nbddcPort),
(self.otherNbddcDipIndex, self.otherNbddcPort),
(self.spectralDipIndex, self.wbddcPort + 4),
(self.demodDipIndex, self.wbddcPort + 5),
):
self.setDipEntry(dipIndex, udpPort)
self.disableWbddc(True)
self.disableNbddc(True)
self.updateWbddc()
self.updateNbddc()
self.updateTuner()
self.updateCal()
def __init__(
self,
verbose_mode=True,
radio_device_name="/dev/ndr47x",
radio_baud_rate=921600,
gig_iface_to_use="eth0",
num_tuners=1,
tuner1_param_list=[False, 900e6, 0],
tuner2_param_list=[False, 900e6, 0],
num_wbddcs=1,
wbddc1_param_list=[40001, 0, 0, False, 0e6],
wbddc2_param_list=[40002, 0, 0, False, 0e6],
tagged=False,
):
gr.hier_block2.__init__(
self,
"[CyberRadio] NDR472 Source",
gr.io_signature(0, 0, 0),
gr.io_signaturev(num_wbddcs + 1, num_wbddcs + 1,
[gr.sizeof_char * 1] +
num_wbddcs * [gr.sizeof_gr_complex * 1]),
)
self.verbose_mode = verbose_mode
self.radio_device_name = radio_device_name
self.radio_baud_rate = radio_baud_rate
self.gig_iface_to_use = gig_iface_to_use
self.udp_host_name = CyberRadioDriver.getInterfaceAddresses(
self.gig_iface_to_use)[1]
self.num_tuners = num_tuners
self.tuner1_param_list = tuner1_param_list
self.tuner2_param_list = tuner2_param_list
self.num_wbddcs = num_wbddcs
self.wbddc1_param_list = wbddc1_param_list
self.wbddc2_param_list = wbddc2_param_list
self.tagged = tagged
self.CyberRadio_file_like_object_source_0 = CyberRadio.file_like_object_source(
)
self.connect((self.CyberRadio_file_like_object_source_0, 0), (self, 0))
self.CyberRadio_NDR_driver_interface_0 = CyberRadio.NDR_driver_interface(
radio_type="ndr472",
verbose=verbose_mode,
log_file=self.CyberRadio_file_like_object_source_0,
connect_mode="tty",
dev_name=radio_device_name,
baud_rate=radio_baud_rate,
)
self.vita_tail_size = self.CyberRadio_NDR_driver_interface_0.getVitaTailSize(
)
self.vita_payload_size = self.CyberRadio_NDR_driver_interface_0.getVitaPayloadSize(
)
self.vita_header_size = self.CyberRadio_NDR_driver_interface_0.getVitaHeaderSize(
)
self.iq_swapped = self.CyberRadio_NDR_driver_interface_0.isIqSwapped()
self.byte_swapped = self.CyberRadio_NDR_driver_interface_0.isByteswapped(
)
self._set_udp_dest_info()
if self.num_tuners >= 1:
self._set_tuner_param_list(1, tuner1_param_list)
if self.num_tuners >= 2:
self._set_tuner_param_list(2, tuner2_param_list)
self.wbddc_sources = {}
if self.num_wbddcs >= 1:
self.CyberRadio_vita_iq_source_wbddc_1 = self._get_configured_wbddc(
1, wbddc1_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 0),
(self, 1))
self.wbddc_sources[1] = self.CyberRadio_vita_iq_source_wbddc_1
if self.num_wbddcs >= 2:
self.CyberRadio_vita_iq_source_wbddc_2 = self._get_configured_wbddc(
2, wbddc2_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_2, 0),
(self, 2))
self.wbddc_sources[2] = self.CyberRadio_vita_iq_source_wbddc_2
def __init__(
self,
verbose_mode=True,
radio_device_name="/dev/ndr47x",
radio_baud_rate=921600,
gig_iface_to_use="eth0",
coherent_mode=0,
num_tuners=1,
tuner1_param_list=[False, 900e6, 0],
tuner2_param_list=[False, 900e6, 0],
tuner3_param_list=[False, 900e6, 0],
tuner4_param_list=[False, 900e6, 0],
tuner5_param_list=[False, 900e6, 0],
tuner6_param_list=[False, 900e6, 0],
num_wbddcs=1,
wbddc1_param_list=[40001, 0, 0, False, 0e6],
wbddc2_param_list=[40002, 0, 0, False, 0e6],
wbddc3_param_list=[40003, 0, 0, False, 0e6],
wbddc4_param_list=[40004, 0, 0, False, 0e6],
wbddc5_param_list=[40005, 0, 0, False, 0e6],
wbddc6_param_list=[40006, 0, 0, False, 0e6],
tagged=False,
):
gr.hier_block2.__init__(
self,
"[CyberRadio] NDR304 Source",
gr.io_signature(0, 0, 0),
gr.io_signaturev(
(6 if coherent_mode & 0x02 > 0 else num_wbddcs) + 1,
(6 if coherent_mode & 0x02 > 0 else num_wbddcs) + 1,
[gr.sizeof_char * 1] + (6 if coherent_mode & 0x02 > 0 else num_wbddcs) * [gr.sizeof_gr_complex * 1],
),
)
self.verbose_mode = verbose_mode
self.radio_device_name = radio_device_name
self.radio_baud_rate = radio_baud_rate
self.gig_iface_to_use = gig_iface_to_use
self.coherent_mode = coherent_mode
self.tuners_coherent = self.coherent_mode & 0x01 > 0
self.ddcs_coherent = self.coherent_mode & 0x02 > 0
self.udp_host_name = CyberRadioDriver.getInterfaceAddresses(self.gig_iface_to_use)[1]
self.num_tuners = num_tuners
self.tuner1_param_list = tuner1_param_list
if not self.tuners_coherent:
self.tuner2_param_list = tuner2_param_list
self.tuner3_param_list = tuner3_param_list
self.tuner4_param_list = tuner4_param_list
self.tuner5_param_list = tuner5_param_list
self.tuner6_param_list = tuner6_param_list
self.num_wbddcs = num_wbddcs
self.wbddc1_param_list = wbddc1_param_list
if not self.ddcs_coherent:
self.wbddc2_param_list = wbddc2_param_list
self.wbddc3_param_list = wbddc3_param_list
self.wbddc4_param_list = wbddc4_param_list
self.wbddc5_param_list = wbddc5_param_list
self.wbddc6_param_list = wbddc6_param_list
self.tagged = tagged
self.CyberRadio_file_like_object_source_0 = CyberRadio.file_like_object_source()
self.connect((self.CyberRadio_file_like_object_source_0, 0), (self, 0))
self.CyberRadio_NDR_driver_interface_0 = CyberRadio.NDR_driver_interface(
radio_type="ndr304",
verbose=verbose_mode,
log_file=self.CyberRadio_file_like_object_source_0,
connect_mode="tty",
dev_name=radio_device_name,
baud_rate=radio_baud_rate,
)
self.vita_tail_size = self.CyberRadio_NDR_driver_interface_0.getVitaTailSize()
self.vita_payload_size = self.CyberRadio_NDR_driver_interface_0.getVitaPayloadSize()
self.vita_header_size = self.CyberRadio_NDR_driver_interface_0.getVitaHeaderSize()
self.iq_swapped = self.CyberRadio_NDR_driver_interface_0.isIqSwapped()
self.byte_swapped = self.CyberRadio_NDR_driver_interface_0.isByteswapped()
self._set_coherent_mode(self.coherent_mode)
self._set_udp_dest_info()
if self.num_tuners >= 1:
self._set_tuner_param_list(1, tuner1_param_list)
if not self.tuners_coherent:
if self.num_tuners >= 2:
self._set_tuner_param_list(2, tuner2_param_list)
if self.num_tuners >= 3:
self._set_tuner_param_list(3, tuner3_param_list)
if self.num_tuners >= 4:
self._set_tuner_param_list(4, tuner4_param_list)
if self.num_tuners >= 5:
self._set_tuner_param_list(5, tuner5_param_list)
if self.num_tuners >= 6:
self._set_tuner_param_list(6, tuner6_param_list)
self.wbddc_sources = {}
if self.num_wbddcs >= 1:
self.CyberRadio_vita_iq_source_wbddc_1 = self._get_configured_wbddc(1, wbddc1_param_list)
if self.ddcs_coherent:
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 0), (self, 1))
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 1), (self, 2))
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 2), (self, 3))
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 3), (self, 4))
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 4), (self, 5))
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 5), (self, 6))
else:
self.connect((self.CyberRadio_vita_iq_source_wbddc_1, 0), (self, 1))
self.wbddc_sources[1] = self.CyberRadio_vita_iq_source_wbddc_1
if not self.ddcs_coherent:
if self.num_wbddcs >= 2:
self.CyberRadio_vita_iq_source_wbddc_2 = self._get_configured_wbddc(2, wbddc2_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_2, 0), (self, 2))
self.wbddc_sources[2] = self.CyberRadio_vita_iq_source_wbddc_2
if self.num_wbddcs >= 3:
self.CyberRadio_vita_iq_source_wbddc_3 = self._get_configured_wbddc(3, wbddc3_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_3, 0), (self, 3))
self.wbddc_sources[3] = self.CyberRadio_vita_iq_source_wbddc_3
if self.num_wbddcs >= 4:
self.CyberRadio_vita_iq_source_wbddc_4 = self._get_configured_wbddc(4, wbddc4_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_4, 0), (self, 4))
self.wbddc_sources[4] = self.CyberRadio_vita_iq_source_wbddc_4
if self.num_wbddcs >= 5:
self.CyberRadio_vita_iq_source_wbddc_5 = self._get_configured_wbddc(5, wbddc5_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_5, 0), (self, 5))
self.wbddc_sources[5] = self.CyberRadio_vita_iq_source_wbddc_5
if self.num_wbddcs >= 6:
self.CyberRadio_vita_iq_source_wbddc_6 = self._get_configured_wbddc(6, wbddc6_param_list)
self.connect((self.CyberRadio_vita_iq_source_wbddc_6, 0), (self, 6))
self.wbddc_sources[6] = self.CyberRadio_vita_iq_source_wbddc_6
