def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.setCentralWidget(self.mdiArea);
self.statusTxt = QtGui.QLabel("")
self.statusBar().addWidget(self.statusTxt)
self.connect(self.action_Tubotron, SIGNAL("triggered()"), SLOT("Tubotron()"))
self.connect(self.action_Temperature, SIGNAL("triggered()"), SLOT("Temperature()"))
self.connect(self.action_Utilization, SIGNAL("triggered()"), SLOT("Utilization()"))
self.connect(self.action_Frequency, SIGNAL("triggered()"), SLOT("Frequency()"))
self.connect(self.action_SaveData, SIGNAL("triggered()"), SLOT("SaveData()"))
self.connect(self.action_SelectBoard, SIGNAL("triggered()"), SLOT("SelectBoard()"))
self.connect(self.action_CoreSwitcher, SIGNAL("triggered()"), SLOT("CoreSwitch()"))
self.TubSock = QtNetwork.QUdpSocket(self) # this is for Tubotron
self.RptSock = QtNetwork.QUdpSocket(self) # this if for report streaming (temperature, utilization, etc)
self.RplSock = QtNetwork.QUdpSocket(self) # this for generic reply for specific command request
self.initRptSock(DEF.RECV_PORT)
self.initRplSock(DEF.REPLY_PORT)
self.uw = None
self.tw = None
self.fw = None
self.sw = None
# First, trigger the Board type and get the core map
self.SelectBoard()
def __init__(self, def_image_dir="./", parent=None):
self.img_dir = def_image_dir
self.img = None
self.res = None
self.continyu = True
super(edgeGUI, self).__init__(parent)
self.setupUi(self)
self.orgViewPort = imgWidget("Original Image")
#self.orgViewPort.show()
self.resViewPort = imgWidget("Result SpiNNaker")
#self.resViewPort.show()
self.hostViewPort = imgWidget("Result PC-version")
#self.hostViewPort.show()
self.trx = trxIndicator()
#self.trx.show()
self.connect(self.pbLoad, QtCore.SIGNAL("clicked()"),
QtCore.SLOT("pbLoadClicked()"))
self.connect(self.pbSend, QtCore.SIGNAL("clicked()"),
QtCore.SLOT("pbSendClicked()"))
self.connect(self.pbProcess, QtCore.SIGNAL("clicked()"),
QtCore.SLOT("pbProcessClicked()"))
self.connect(self.pbSave, QtCore.SIGNAL("clicked()"),
QtCore.SLOT("pbSaveClicked()"))
self.connect(self.pbClear, QtCore.SIGNAL("clicked()"),
QtCore.SLOT("pbClearClicked()"))
#self.connect(self.cbSpiNN, QtCore.SIGNAL("currentIndexChanged(int)")), QtCore.SLOT("cbSpiNNChanged(int)")
self.cbSpiNN.currentIndexChanged.connect(self.cbSpiNNChanged)
if spiNN == spin3:
self.cbSpiNN.setCurrentIndex(0)
else:
self.cbSpiNN.setCurrentIndex(1)
# self.sdpUpdate can be connected to other slot
# self.sdpUpdate.connect(SOME_OTHER_SLOT)
self.RptSock = QtNetwork.QUdpSocket(self)
self.sdpSender = QtNetwork.QUdpSocket(self)
self.initRptSock(DEF_RESULT_PORT)
# self.initRptSock(DEF_REPLY_PORT)
self.DbgSock = QtNetwork.QUdpSocket(self)
self.initDbgSock(DEF_DEBUG_PORT)
self.tResult = [0, 0, 0]
self.debugVal = 0
self.ResultTriggered = False
def send_server_invite_option(self, invite_client_ids, channel_id):
# for each client_id find the socket on which to send the
# server_invite option
for invite_client_id in invite_client_ids:
for _, client_sockets in self.channels.items():
for (client_id, socket) in client_sockets:
if invite_client_id == client_id:
#Hier kann es auch sein, dass nur eine Id gebraucht
#wird und nicht eine Liste...
option_data = Container(channel_id=channel_id,
client_id=invite_client_ids)
option = Container(option_id="SERVER_INVITE_OPTION",
option_data=option_data)
pdu = Container(id=self.id, option=[option])
ip_to_invite = QtNetwork.QHostAddress(
socket.peerAddress())
udpSocket_for_invites = QtNetwork.QUdpSocket(self)
udpSocket_for_invites.bind(
ip_to_invite, broadcast_port,
QtNetwork.QUdpSocket.ShareAddress)
udpSocket_for_invites.writeDatagram(
InstantSoupData.peer_pdu.build(pdu), ip_to_invite,
broadcast_port)
log.debug('PDU: SERVER_INVITE_OPTION - id: %i - SENT' %
self.pdu_number)
def __init__(self, argv):
QtGui.QApplication.__init__(self, argv)
settings = utils.Settings()
# Prepare socket for sending notifications
self.socketTo = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socketTo.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.socketTo.connect(('255.255.255.255', settings.notificationPort))
# Prepare socket for receiving notifications
self.socketFrom = QtNetwork.QUdpSocket()
anyAddress = QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any)
self.socketFrom.bind(anyAddress, settings.notificationPort)
self.connect(self.socketFrom, SIGNAL("readyRead()"),
self.onNotification)
# Prepare the ping agent
self.pingAgent = PingAgent(self, settings.dbHost)
# Run the timer which checks the connection periodically
self.connectionTimer = QTimer(self)
self.connect(self.connectionTimer, SIGNAL("timeout()"),
self.checkConnection)
# Check the connection every 16 seconds if the connection is lost
# or every 5 minutes if the connection is here
self.connectionTimer.start(16 * 1000)
# Check it at the very beginning
QtCore.QTimer.singleShot(1000, self.checkConnection)
def __init__(self, parent=None):
super(proxies, self).__init__(parent)
self.client = parent
self.proxies = {}
self.proxiesDestination = {}
port = 12000
errored = False
for i in range(11) :
port = port + 1
self.proxies[i] = QtNetwork.QUdpSocket(self)
if not self.proxies[i].bind(QtNetwork.QHostAddress.LocalHost, port) :
self.__logger.warn("Can't bind socket %i" % i)
errored = True
else :
self.__logger.info("binding socket %i on port %i" % (i, self.proxies[i].localPort()))
self.proxies[i].readyRead.connect(functools.partial(self.processPendingDatagrams, i))
self.proxiesDestination[i] = None
if errored:
QtGui.QMessageBox.warning(self.client, "Cannot use proxy server", "FAF is unable to bind the port <b>12000 to 12011 on TCP</b>.<br>Please check your firewall settings.<br><b>You may experience connections problems until it's fixed.</b>")
self.proxySocket = QtNetwork.QTcpSocket(self)
self.proxySocket.connected.connect(self.connectedProxy)
self.proxySocket.readyRead.connect(self.readData)
self.proxySocket.disconnected.connect(self.disconnectedFromProxy)
self.blockSize = 0
self.uid = None
self.canClose = False
self.testedPortsAmount = {}
self.testedPorts = []
self.testedLoopbackAmount = {}
self.testedLoopback = []
self.testing = False
def __init__(self, parent=None):
super(Sender, self).__init__(parent)
self.statusLabel = QtGui.QLabel("Ready to broadcast datagrams on port 45454")
self.startButton = QtGui.QPushButton("&Start")
quitButton = QtGui.QPushButton("&Quit")
buttonBox = QtGui.QDialogButtonBox()
buttonBox.addButton(self.startButton, QtGui.QDialogButtonBox.ActionRole)
buttonBox.addButton(quitButton, QtGui.QDialogButtonBox.RejectRole)
self.timer = QtCore.QTimer(self)
self.udpSocket = QtNetwork.QUdpSocket(self)
self.messageNo = 1
self.startButton.clicked.connect(self.startBroadcasting)
quitButton.clicked.connect(self.close)
self.timer.timeout.connect(self.broadcastDatagramm)
mainLayout = QtGui.QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Broadcast Sender")
def sendSDP(self, flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3,
bArray):
"""
You know, the detail experiment with sendSDP() see mySDPinger.py
the bArray can be constructed simply by using type casting. Ex:
elements = [0, 200, 50, 25, 10, 255]
bArray = bytearray(elements) # byte must be in range(0, 256)
Something wrong with bArray -> try to use list instead
"""
da = (dax << 8) + day
dpc = (dp << 5) + dc
sa = 0
spc = 255
pad = struct.pack('2B', 0, 0)
hdr = struct.pack('4B2H', flags, tag, dpc, spc, da, sa)
scp = struct.pack('2H3I', cmd, seq, arg1, arg2, arg3)
sdp = pad + hdr + scp
"""
if bArray is not None:
sdp = pad + hdr + scp + bArray
else:
sdp = pad + hdr + scp
"""
if bArray is not None:
for b in bArray:
sdp += struct.pack('<B', b)
#sdp += b
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST),
DEF_SEND_PORT)
time.sleep(DEF_SDP_TIMEOUT)
return sdp
def create_udp_socket(self):
self.udp_socket = QtNetwork.QUdpSocket()
self.udp_socket.bind(broadcast_port,
QtNetwork.QUdpSocket.ReuseAddressHint)
self.udp_socket.joinMulticastGroup(group_address_ip4)
# connect the socket input with the processing function
self.udp_socket.readyRead.connect(self._process_pending_datagrams)
def __init__(self, parent):
QtCore.QObject.__init__(self, parent)
self.socket = QtNetwork.QUdpSocket(self)
self.socket.bind(1137)
self.connect(self.socket, QtCore.SIGNAL("readyRead()"), self.process_datagrams)
self.count = 0
parent.txtSocket.setPlainText("RiiFS Python Server is now ready for connections on 1137")
def sendAck(self, blkID):
# Try with broadcasting method only
# sendSDP(self,flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray):
# dp = sdpImgConfigPort
dpc = (sdpAckPort << 5) + sdpCore
hdr = struct.pack('4B2H', 0x07, 0, dpc, 255, 0, 0)
reply = QtNetwork.QUdpSocket()
self.sendSDP(0x07, 0, sdpAckPort, sdpCore, 0, 0, 0, 0, 0, 0, 0, None)
def __init__(self):
QtGui.QDialog.__init__(self)
self.ui = Ui_EventMessageDialog()
self.ui.setupUi(self)
self.setWindowTitle(pageTitle)
self.udpSocket = QtNetwork.QUdpSocket(self)
self.udpSocket.bind(int(udpPort))
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
def __init__(self, listen_port, parent=None):
super(dp_udp, self).__init__(parent)
self.ListenPort = listen_port
print "Listening on UDP port %d" % listen_port
self.udpSocket = QtNetwork.QUdpSocket(self)
self.udpSocket.bind(QtNetwork.QHostAddress.Any, self.ListenPort)
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
def __init__(self, send_port, targetIP, parent=None):
super(UDP_sendStatus, self).__init__(parent)
self.sendPort = num(send_port)
self.target_IP = QtNetwork.QHostAddress(targetIP)
try:
self.ss = QtNetwork.QUdpSocket(self)
except:
print "Trouble opening UDP on socket %d" % (self.sendPort)
def setupUDP(self):
self.sdpRecv = QtNetwork.QUdpSocket(self)
print "[INFO] Trying to open UDP port-{}...".format(
SDP_SEND_RESULT_PORT),
ok = self.sdpRecv.bind(SDP_SEND_RESULT_PORT)
if ok:
print "done!"
else:
print "fail!"
self.sdpRecv.readyRead.connect(self.readSDP)
def __init__(self, msg, parent=None):
super(Sender, self).__init__(parent)
self.msg = str(msg)
self.dataconf = configset.read_config()
self.setGeometry(0, 0, 0, 0)
self.timer = QtCore.QTimer(self)
self.udpSocket = QtNetwork.QUdpSocket(self)
self.timer.timeout.connect(self.broadcastDatagramm)
self.broadcastDatagramm()
def __init__(self):
QtGui.QDialog.__init__(self)
self.ui = Ui_GenericTelemetryDialog()
self.ui.setupUi(self)
self.setWindowTitle(pageTitle)
#
# connect the method to process a UDP packet
#
self.udpSocket = QtNetwork.QUdpSocket(self)
self.udpSocket.bind(int(udpPort))
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
def sendImgInfo(self, cmd, data_type):
dpc = (SDP_RECV_JPG_INFO_PORT <<
5) + SDP_RECV_CORE_ID #destination port and core
pad = struct.pack('2B', 0, 0)
hdr = struct.pack('4B2H', 7, 0, dpc, 255, 0, 0)
scp = struct.pack('2H3I', cmd, data_type, self.szImgFile, 0, 0)
sdp = pad + hdr + scp
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(self.spinn),
SPINN_PORT)
CmdSock.flush()
# then give a break, otherwise spinnaker will collapse
self.delay()
def sendChunk(ch_port, ba):
da = 0
dpc = (ch_port << 5) + 1
sa = 0
spc = 255
pad = struct.pack('<2B', 0, 0)
hdr = struct.pack('<4B2H', 7, 0, dpc, spc, da, sa)
sdp = pad + hdr + ba
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST), DEF_SEND_PORT)
CmdSock.flush()
def sendImgInfo(self):
dpc = (SDP_RECV_RAW_INFO_PORT <<
5) + SDP_RECV_CORE_ID # destination port and core
pad = struct.pack('2B', 0, 0)
hdr = struct.pack('4B2H', 7, 0, dpc, 255, 0, 0)
scp = struct.pack('2H3I', SDP_CMD_INIT_SIZE, 0, len(self.orgImg),
self.wImg, self.hImg)
sdp = pad + hdr + scp
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(self.spinn),
SPINN_PORT)
CmdSock.flush()
# then give a break, otherwise spinnaker might collapse
self.delay()
def __init__(self, parent=None, device_id=None):
pygame.init()
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
QtCore.QObject.connect(self.ui.pushButton_stream_webcam,
QtCore.SIGNAL("clicked()"),
self.cmd_stream_webcam)
QtCore.QObject.connect(self.ui.horizontalSlider_fps,
QtCore.SIGNAL("valueChanged(int)"),
self.cmd_fps_changed)
QtCore.QObject.connect(self.ui.verticalSlider_red,
QtCore.SIGNAL("valueChanged(int)"),
self.cmd_red_slider_changed)
QtCore.QObject.connect(self.ui.verticalSlider_green,
QtCore.SIGNAL("valueChanged(int)"),
self.cmd_green_slider_changed)
QtCore.QObject.connect(self.ui.verticalSlider_blue,
QtCore.SIGNAL("valueChanged(int)"),
self.cmd_blue_slider_changed)
QtCore.QObject.connect(self.ui.verticalSlider_gamma,
QtCore.SIGNAL("valueChanged(int)"),
self.cmd_gamma_slider_changed)
QtCore.QObject.connect(self.ui.verticalSlider_brightness,
QtCore.SIGNAL("valueChanged(int)"),
self.cmd_brightness_slider_changed)
# Network init
self.sock = QtNetwork.QUdpSocket()
self.sock.bind(QtNetwork.QHostAddress.Any, PORT)
self.connect(self.sock, QtCore.SIGNAL("readyRead()"),
self.on_recv_udp_packet)
self.image = None
self.streaming = False
self.threshold = 128
self.equalize = False
self.fps = FRAMES_PER_SECOND
self.time_between_frames = TIME_BETWEEN_FRAMES
self.max_red = 100
self.max_green = 100
self.max_blue = 100
self.max_gamma = 100
self.max_brightness = 100
def sendChunk(ch_port, core, seq, ba):
da = 0
dpc = (ch_port << 5) + core
sa = seq
spc = 255
pad = struct.pack('<2B',0,0)
hdr = struct.pack('<4B2H',7,0,dpc,spc,da,sa)
if ba is not None:
sdp = pad + hdr + ba
else:
sdp = pad + hdr
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST), DEF_SEND_PORT)
CmdSock.flush()
def __init__(self):
QtGui.QWidget.__init__(self)
self._parser = parserlog.parser()
self.dataconf = configset.read_config()
self.udpSocket = QtNetwork.QUdpSocket(self)
self.statusText = "Stop"
self.sqlA = '''CREATE TABLE IF NOT EXISTS [datatemp](
[id] BIGINT(100) NOT NULL PRIMARY KEY,
[pid] VARCHAR(255) NOT NULL,
[name] VARCHAR(255) NOT NULL,
[addinfo] VARCHAR(255) NOT NULL)'''
#self.conn = sqlite.connect(os.environ['TEMP'] + '\\' + 'dtemp.db')
self.conn = sqlite.connect('dtemp.db')
self.curs = self.conn.cursor()
self.process = QtCore.QProcess()
#self.createIconGroupBox()
#self.createMessageGroupBox()
#self.iconLabel.setMinimumWidth(self.durationLabel.sizeHint().width())
self.createActions()
self.createTrayIcon()
self.setIcon()
#QtCore.QObject.connect(self.showMessageButton,
# QtCore.SIGNAL("clicked()"), self.showMessage)
#QtCore.QObject.connect(self.showIconCheckBox,
# QtCore.SIGNAL("toggled(bool)"), self.trayIcon,
# QtCore.SLOT("setVisible(bool)"))
#QtCore.QObject.connect(self.iconComboBox,
# QtCore.SIGNAL("currentIndexChanged(int)"), self.setIcon)
#QtCore.QObject.connect(self.trayIcon,
# QtCore.SIGNAL("messageClicked()"), self.messageClicked)
#QtCore.QObject.connect(self.trayIcon,
# QtCore.SIGNAL("activated(QSystemTrayIcon::ActivationReason)"),
# self.iconActivated)
#mainLayout = QtGui.QVBoxLayout()
#mainLayout.addWidget(self.iconGroupBox)
#mainLayout.addWidget(self.messageGroupBox)
#self.setLayout(mainLayout)
#self.iconComboBox.setCurrentIndex(1)
self.trayIcon.show()
def sendSDP(flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray):
da = (dax << 8) + day
dpc = (dp << 5) + dc
sa = 0
spc = 255
pad = struct.pack('<2B', 0, 0)
hdr = struct.pack('<4B2H', flags, tag, dpc, spc, da, sa)
scp = struct.pack('<2H3I', cmd, seq, arg1, arg2, arg3)
if bArray is not None:
sdp = pad + hdr + scp + bArray
else:
sdp = pad + hdr + scp
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST), DEF_SEND_PORT)
CmdSock.flush()
return sdp
def sendChunk(self, chunk):
# based on sendSDP()
# will be sent to chip <0,0>, no SCP
dpc = (SDP_RECV_RAW_DATA_PORT <<
5) + SDP_RECV_CORE_ID # destination port and core
pad = struct.pack('2B', 0, 0)
hdr = struct.pack('4B2H', 7, 0, dpc, 255, 0, 0)
if chunk is not None:
sdp = pad + hdr + chunk
else:
# empty sdp means end of image transmission
sdp = pad + hdr
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(self.spinn),
SPINN_PORT)
CmdSock.flush()
# then give a break, otherwise spinnaker will collapse
self.delay()
def sendSDP(self,flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray):
"""
The detail experiment with sendSDP() see mySDPinger.py
"""
da = (dax << 8) + day
dpc = (dp << 5) + dc
sa = 0
spc = 255
pad = struct.pack('2B',0,0)
hdr = struct.pack('4B2H',flags,tag,dpc,spc,da,sa)
scp = struct.pack('2H3I',cmd,seq,arg1,arg2,arg3)
if bArray is not None:
sdp = pad + hdr + scp + bArray
else:
sdp = pad + hdr + scp
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF.HOST), DEF.SEND_PORT)
return sdp
def sendFreqReq(self, freq, dax, day):
#def sendFreqReq(self,flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray):
"""
The detail experiment with sendSDP() see mySDPinger.py
"""
da = (dax << 8) + day
dpc = (DEF.SDP_PORT << 5) + DEF.SDP_CORE
sa = 0
spc = 255
pad = struct.pack('2B', 0, 0)
hdr = struct.pack('4B2H', DEF.NO_REPLY, DEF.SEND_IPTAG, dpc, spc, da,
sa)
scp = struct.pack('2H3I', DEF.HOST_SET_FREQ_VALUE, freq, 0, 0, 0)
sdp = pad + hdr + scp
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF.HOST),
DEF.SEND_PORT)
return sdp
def __init__(self):
QtGui.QWidget.__init__(self)
self._parser = parserlog.parser()
self.dataconf = configset.read_config()
self.udpSocket = QtNetwork.QUdpSocket(self)
self.statusText = "Stop"
self.sqlA = '''CREATE TABLE IF NOT EXISTS [datatemp](
[id] BIGINT(100) NOT NULL PRIMARY KEY,
[pid] VARCHAR(255) NOT NULL,
[name] VARCHAR(255) NOT NULL,
[addinfo] VARCHAR(255) NOT NULL)'''
self.conn = sqlite.connect('totalcmd_dtemp.db')
self.curs = self.conn.cursor()
self.process = QtCore.QProcess()
self.createActions()
self.createTrayIcon()
self.setIcon()
self.trayIcon.show()
def __init__(self, parent=None):
super(Receiver, self).__init__(parent)
self.statusLabel = QtGui.QLabel("Listening for broadcasted messages")
quitButton = QtGui.QPushButton("&Quit")
self.udpSocket = QtNetwork.QUdpSocket(self)
self.udpSocket.bind(45454)
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
quitButton.clicked.connect(self.close)
buttonLayout = QtGui.QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(quitButton)
buttonLayout.addStretch(1)
mainLayout = QtGui.QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.setWindowTitle("Broadcast Receiver")
self.timer.timeout.connect(self.update_plots)
self.timer.start(20)
self.amp = amp
self.box_phase = phase
@QtCore.pyqtSlot()
def update_plots(self):
self.penAmp.setData(self.carrier, self.amplitude)
self.penPhase.setData(self.carrier, self.phase)
self.process_events() ## force complete redraw for every plot
def process_events(self):
self.app.processEvents()
## Start Qt event loop unless running in interactive mode.
if (__name__ == '__main__'):
import sys
udp_port = 1234
udpSocket = QtNetwork.QUdpSocket()
udpSocket.bind(udp_port, QtNetwork.QUdpSocket.ShareAddress)
form = UI(app=app)
form.show()
e = UDP_listener([], [], sock=udpSocket, form=form)
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
def __init__(self, parent=None):
super(sdpComm, self).__init__(parent)
self.RptSock = QtNetwork.QUdpSocket(self)
self.initSDPReceiver()
