class Comm(): def __init__(self, address, port): self.block = 0 self.port = port self.delimiter = bytes('x', 'utf-8') self.address = address self.block = bytearray() self.initialize(address, port) def initialize(self, address, port): self.socket = QTcpSocket() self.socket.connectToHost(self.address, self.port) def decode(self, data): return data.decode('utf-8').replace('\x00', '').rsplit() def read(self): self.size = self.socket.bytesAvailable() self.block += self.socket.read(self.size) def get_data(self): if (self.delimiter in self.block): data = self.block[0:self.block.index(self.delimiter)] data = list(map(int, self.decode(data))) self.block = self.block[self.block.index(self.delimiter) + 1:-1] return data def send(self, data): self.socket.write(bytearray(data, 'utf-8')) def disconnect(self): self.socket.close()
def exchangeData(self): if not checkIPAddress(ip_line_edit.text()): raise Exception("ERROR IP-address format") tcp_socket = QTcpSocket() tcp_socket.connectToHost(ip_line_edit.text(), 80, QIODevice.ReadWrite) self.update.emit( f"Connecting to {tcp_socket.peerAddress().toString()}:{tcp_socket.peerPort()}" ) if not tcp_socket.waitForConnected(5000): raise Exception(f"ERROR connecting to {ip_line_edit.text()}:80") tcp_socket.waitForReadyRead(5000) arduino_state: bytes = b"" while tcp_socket.bytesAvailable() > 0: arduino_state += tcp_socket.readAll().data() print(arduino_state) arduino_state = arduino_state.decode() if ("+" not in arduino_state): raise Exception(f"ERROR incomplete read") self.updateState(arduino_state) tcp_socket.write((self.getState() + "+\n").encode("utf-8")) tcp_socket.flush() if tcp_socket.bytesToWrite() > 0: raise Exception(f"ERROR incomplete write") tcp_socket.disconnectFromHost() tcp_socket.close()
def run(self): self.mutex.lock() serverName = self.hostName serverPort = self.port self.mutex.unlock() while not self.quit: Timeout = 5 * 1000 socket = QTcpSocket() socket.connectToHost(serverName, serverPort) if not socket.waitForConnected(Timeout): self.error.emit(socket.error(), socket.errorString()) return while socket.bytesAvailable() < 2: if not socket.waitForReadyRead(Timeout): self.error.emit(socket.error(), socket.errorString()) return instr = QDataStream(socket) instr.setVersion(QDataStream.Qt_4_0) blockSize = instr.readUInt16() while socket.bytesAvailable() < blockSize: if not socket.waitForReadyRead(Timeout): self.error.emit(socket.error(), socket.errorString()) return self.mutex.lock() fortune = instr.readQString() self.newFortune.emit(fortune) self.cond.wait(self.mutex) serverName = self.hostName serverPort = self.port self.mutex.unlock()
def run(self): self.mutex.lock() serverName = self.hostName serverPort = self.port self.mutex.unlock() while not self.quit: Timeout = 5 * 1000 socket = QTcpSocket() socket.connectToHost(serverName, serverPort) if not socket.waitForConnected(Timeout): self.error.emit(socket.error(), socket.errorString()) return while socket.bytesAvailable() < 2: if not socket.waitForReadyRead(Timeout): self.error.emit(socket.error(), socket.errorString()) return instr = QDataStream(socket) instr.setVersion(QDataStream.Qt_4_0) blockSize = instr.readUInt16() while socket.bytesAvailable() < blockSize: if not socket.waitForReadyRead(Timeout): self.error.emit(socket.error(), socket.errorString()) return self.mutex.lock() fortune = instr.readQString() self.newFortune.emit(fortune) self.cond.wait(self.mutex) serverName = self.hostName serverPort = self.port self.mutex.unlock()
class SocketTest(QObject): def __init__(self, parent=None): super(SocketTest, self).__init__(parent) def connect(self): self.socket = QTcpSocket(self) self.socket.connectToHost(IP, PORT) if self.socket.waitForConnected(3000): print('Connected') self.socket.waitForReadyRead(3000) print(self.socket.bytesAvailable(), self.socket.readAll()) else: print('Not Connected')
class Client(QObject): def __init__(self, parent=None): super().__init__(parent) self.log = logging.getLogger(__name__) self._socket_setup() def _socket_setup(self): self.socket = QTcpSocket(self) self.socket.setSocketOption(QTcpSocket.KeepAliveOption, 1) self.socket.connected.connect(self.on_connected) self.socket.disconnected.connect(self.on_disconnected) self.socket.readyRead.connect(self.on_readyRead) self.socket.error.connect(self.on_error) self.socket.stateChanged.connect(self.on_stateChanged) def connect(self, host=HOST, port=PORT): if not self.socket.isOpen(): self.log.info('connecting to {}:{}'.format(host, port)) self.socket.connectToHost(QHostAddress(host), port) def disconnect(self): self.log.info('disconnecting') self.socket.disconnectFromHost() def on_readyRead(self): data = bytes() while self.socket.bytesAvailable(): data += self.socket.read(1024) self.log.debug(data) def on_connected(self): self.log.info('connected') def on_disconnected(self): self.log.info('disconnected') def on_error(self, error): self.log.error('error {}: {}'.format(error, self.socket.errorString())) def on_stateChanged(self, state): states = ['Unconnected', 'HostLookup', 'Connecting', 'Connected', 'Bound', 'Closing', 'Listening'] self.log.debug('state changed to {}'.format(states[state]))
class TcpClient(): def __init__(self, line_edit_widget=None, text_widget=None): self.line_edit = line_edit_widget self.text_widget = text_widget self.socket = QTcpSocket() # client "is a" socket def connect_server(self): print('inside connect_server') print('Port is: ' + str(SERVER_PORT)) self.socket.connectToHost(SERVER_ADDRESS, SERVER_PORT) def write_data(self): data_byte_array = QByteArray() stream = QDataStream(data_byte_array, QIODevice.WriteOnly) stream.setVersion(QDataStream.Qt_5_9) stream.writeUInt32(0) if self.line_edit: print('inside write_data') stream.writeQString(self.line_edit.text()) self.socket.write(data_byte_array) data_byte_array = None if self.line_edit: self.line_edit.setText("") def read_data(self): stream = QDataStream(self.socket) stream.setVersion(QDataStream.Qt_5_9) while True: if self.socket.bytesAvailable() <= 0: break stream.readUInt32() text_from_server = stream.readQString() if self.text_widget: print('display_text') print(text_from_server) self.text_widget.append(text_from_server)
def run(self): self.log.debug(f'Connection "{self.name}" is starting') def wait_and_read(n_bytes, wait_ms): "Convinience function that simplifies checking for stop events, etc." if sock.bytesAvailable() == 0: new_data = sock.waitForReadyRead(wait_ms) if not new_data: return None return sock.read(n_bytes) sock = QTcpSocket(None) # import pdb; pdb.set_trace() sock.setSocketDescriptor(self.socketDescriptor) sock.waitForConnected() while True: if sock.state() != sock.ConnectedState or self.need_to_stop(): self.log.debug(f'Connection "{self.name}" is stopping') break read_len = wait_and_read(4, 100) if not read_len: continue read_len = struct.unpack(">L", read_len)[0] if sock.bytesAvailable() == 0: sock.waitForReadyRead() data = sock.read(read_len) if not data: continue data = pickle.loads(data) record = logging.makeLogRecord(data) self.new_record.emit(record) sock.disconnectFromHost() sock.close() self.connection_finished.emit(int(self.socketDescriptor)) self.log.debug(f'Connection "{self.name}" has stopped')
class TcpC(QDialog, Ui_TcpClient): """ Class documentation goes here. """ def __init__(self, parent=None): """ Constructor @param parent reference to the parent widget @type QWidget """ super(TcpC, self).__init__(parent) self.setupUi(self) self.TotalBytes = 0 self.bytesReceive = 0 self.fileNameSize = 0 self.bytesToReceive = 0 self.fileName = "" self.tcpClient = QTcpSocket(self) self.tcpPort = 7788 self.time = QTime() self.tcpClient.readyRead.connect(self.readMessage) self.tcpClient.error.connect(self.displayError) def setHostAddress(self, address): """ 设置服务器地址 """ self.hostAddress = address self.newConnect() def setFileName(self, file): """ 待接收文件的文件名 """ self.localFile = QFile(file) def closeEvent(self, event): """ 关闭事件 """ self.on_tcpClientCloseBtn_clicked() def newConnect(self): """ 连接服务器并开始计时 """ self.tcpClient.abort() self.tcpClient.connectToHost(self.hostAddress, self.tcpPort) self.time.start() def readMessage(self): """ 读取文件数据 """ receiver = QDataStream(self.tcpClient) receiver.setVersion(QDataStream.Qt_5_4) if self.bytesReceive <= 2: if self.tcpClient.bytesAvailable() >= 2 and self.fileNameSize == 0: self.TotalBytes = receiver.readInt64() self.fileNameSize = receiver.readInt64() self.bytesReceive += 2 if self.tcpClient.bytesAvailable() >= self.fileNameSize and self.fileNameSize != 0: self.fileName = receiver.readQString() self.bytesReceive += self.fileNameSize if not(self.localFile.open(QFile.WriteOnly)): QMessageBox.warning(self, "应用程序", "无法读取文件 {}:\n {}".format(self.fileName, self.localFile.errorString())) return else: return if self.bytesReceive < self.TotalBytes: self.bytesReceive += self.tcpClient.bytesAvailable() inBlock = self.tcpClient.readAll() self.localFile.write(inBlock) inBlock.resize(0) useTime = self.time.elapsed() / 1000 bytesReceived = self.bytesReceive / (1024*1024) speed = bytesReceived / useTime total = self.TotalBytes / (1024*1024) left = (total - bytesReceived) / speed if bytesReceived < 0.01: bytesReceived = self.bytesReceive / 1024 speed = bytesReceived / useTime / 1024 total = self.TotalBytes / 1024 if left > 0: msg = "已接收 {0:.2f} KB ({1:.2f}KB/s)\n共{2:.2f}KB.已用时:{3:.1f}秒\n估计剩余时间:{4:.1f}秒".format(bytesReceived, speed, total, useTime, left) else: msg = "已接收 {0:.2f} KB ({1:.2f}KB/s)\n共{2:.2f}KB.已用时:{3:.1f}秒\n".format(bytesReceived, speed, total, useTime) else: if left > 0: msg = "已接收 {0:.2f} MB ({1:.2f}MB/s)\n共{2:.2f}MB.已用时:{3:.1f}秒\n估计剩余时间:{4:.1f}秒".format(bytesReceived, speed, total, useTime, left) else: msg = "已接收 {0:.2f} MB ({1:.2f}MB/s)\n共{2:.2f}MB.已用时:{3:.1f}秒\n".format(bytesReceived, speed, total, useTime) self.progressBar.setMaximum(total) self.progressBar.setValue(bytesReceived) self.tcpClientStatuslabel.setText(msg) if self.bytesReceive == self.TotalBytes: self.localFile.close() self.tcpClient.close() self.tcpClientStatuslabel.setText("接收文件{}完毕".format(self.fileName)) self.tcpClientBtn.setEnabled(False) def displayError(self, socketError): """ 显示错误 """ if socketError == QAbstractSocket.RemoteHostClosedError: pass else: errorMsg = self.tcpClient.errorString() QMessageBox.warning(self, "应用程序", errorMsg) return @pyqtSlot() def on_tcpClientBtn_clicked(self): """ 取消接收 """ self.tcpClient.abort() if self.localFile.isOpen(): self.localFile.close() self.tcpClientBtn.setEnabled(False) @pyqtSlot() def on_tcpClientCloseBtn_clicked(self): """ 关闭 """ self.tcpClient.abort() if self.localFile.isOpen(): self.localFile.close() self.close() self.tcpClientBtn.setEnabled(True)
class Scanner(QMainWindow, Ui_Scanner): def __init__(self): super(Scanner, self).__init__() self.setupUi(self) # IP address validator rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$') self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue)) # state variable self.idle = True # number of samples to show on the plot self.size = 512 * 512 self.freq = 143.0 # buffer and offset for the incoming samples self.buffer = bytearray(8 * self.size) self.offset = 0 self.data = np.frombuffer(self.buffer, np.int32) # create figure figure = Figure() figure.set_facecolor('none') self.axes = figure.add_subplot(111) self.canvas = FigureCanvas(figure) self.plotLayout.addWidget(self.canvas) self.axes.axis((0.0, 512.0, 0.0, 512.0)) x, y = np.meshgrid(np.linspace(0.0, 512.0, 513), np.linspace(0.0, 512.0, 513)) z = x / 512.0 + y * 0.0 self.mesh = self.axes.pcolormesh(x, y, z, cmap = cm.plasma) # create navigation toolbar self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False) # remove subplots action actions = self.toolbar.actions() if int(matplotlib.__version__[0]) < 2: self.toolbar.removeAction(actions[7]) else: self.toolbar.removeAction(actions[6]) self.plotLayout.addWidget(self.toolbar) # create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # connect signals from buttons and boxes self.connectButton.clicked.connect(self.start) self.scanButton.clicked.connect(self.scan) self.periodValue.valueChanged.connect(self.set_period) self.trgtimeValue.valueChanged.connect(self.set_trgtime) self.trginvCheck.stateChanged.connect(self.set_trginv) self.shdelayValue.valueChanged.connect(self.set_shdelay) self.shtimeValue.valueChanged.connect(self.set_shtime) self.shinvCheck.stateChanged.connect(self.set_shinv) self.acqdelayValue.valueChanged.connect(self.set_acqdelay) self.samplesValue.valueChanged.connect(self.set_samples) self.pulsesValue.valueChanged.connect(self.set_pulses) # create timers self.startTimer = QTimer(self) self.startTimer.timeout.connect(self.timeout) self.meshTimer = QTimer(self) self.meshTimer.timeout.connect(self.update_mesh) # set default values self.periodValue.setValue(200.0) def start(self): if self.idle: self.connectButton.setEnabled(False) self.socket.connectToHost(self.addrValue.text(), 1001) self.startTimer.start(5000) else: self.stop() def stop(self): self.idle = True self.socket.abort() self.offset = 0 self.connectButton.setText('Connect') self.connectButton.setEnabled(True) self.scanButton.setEnabled(True) def timeout(self): self.display_error('timeout') def connected(self): self.startTimer.stop() self.idle = False self.set_period(self.periodValue.value()) self.set_trgtime(self.trgtimeValue.value()) self.set_trginv(self.trginvCheck.checkState()) self.set_shdelay(self.shdelayValue.value()) self.set_shtime(self.shtimeValue.value()) self.set_shinv(self.shinvCheck.checkState()) self.set_acqdelay(self.acqdelayValue.value()) self.set_samples(self.samplesValue.value()) self.set_pulses(self.pulsesValue.value()) # start pulse generators self.socket.write(struct.pack('<I', 9<<28)) self.connectButton.setText('Disconnect') self.connectButton.setEnabled(True) self.scanButton.setEnabled(True) def read_data(self): size = self.socket.bytesAvailable() if self.offset + size < 8 * self.size: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: self.meshTimer.stop() self.buffer[self.offset:8 * self.size] = self.socket.read(8 * self.size - self.offset) self.offset = 0 self.update_mesh() self.scanButton.setEnabled(True) def display_error(self, socketError): self.startTimer.stop() if socketError == 'timeout': QMessageBox.information(self, 'Scanner', 'Error: connection timeout.') else: QMessageBox.information(self, 'Scanner', 'Error: %s.' % self.socket.errorString()) self.stop() def set_period(self, value): # set maximum delays and times to half period maximum = int(value * 5.0 + 0.5) / 10.0 self.trgtimeValue.setMaximum(maximum) self.shdelayValue.setMaximum(maximum) self.shtimeValue.setMaximum(maximum) self.acqdelayValue.setMaximum(maximum) # set maximum number of samples per pulse maximum = int(value * 500.0 + 0.5) / 10.0 if maximum > 256.0: maximum = 256.0 self.samplesValue.setMaximum(maximum) shdelay = value * 0.25 samples = value * 0.5 if self.idle: return self.socket.write(struct.pack('<I', 0<<28 | int(value * self.freq))) def set_trgtime(self, value): if self.idle: return self.socket.write(struct.pack('<I', 1<<28 | int(value * self.freq))) def set_trginv(self, checked): if self.idle: return self.socket.write(struct.pack('<I', 2<<28 | int(checked == Qt.Checked))) def set_shdelay(self, value): if self.idle: return self.socket.write(struct.pack('<I', 3<<28 | int(value * self.freq))) def set_shtime(self, value): if self.idle: return self.socket.write(struct.pack('<I', 4<<28 | int(value * self.freq))) def set_shinv(self, checked): if self.idle: return self.socket.write(struct.pack('<I', 5<<28 | int(checked == Qt.Checked))) def set_acqdelay(self, value): if self.idle: return self.socket.write(struct.pack('<I', 6<<28 | int(value * self.freq))) def set_samples(self, value): if self.idle: return self.socket.write(struct.pack('<I', 7<<28 | int(value))) def set_pulses(self, value): if self.idle: return self.socket.write(struct.pack('<I', 8<<28 | int(value))) def scan(self): if self.idle: return self.scanButton.setEnabled(False) self.data[:] = np.zeros(2 * 512 * 512, np.int32) self.update_mesh() self.socket.write(struct.pack('<I', 10<<28)) self.meshTimer.start(1000) def update_mesh(self): self.mesh.set_array(self.data[0::2]/(self.samplesValue.value() * self.pulsesValue.value() * 8192.0)) self.canvas.draw()
class ControlCar(QWidget): HOST = "127.0.0.1" PORT = 8888 def __init__(self, *args, **kwargs): super(ControlCar, self).__init__(*args, **kwargs) self._conn = None # 加载UI文件 uic.loadUi('carui.ui', self) self.resize(800, 600) # 绑定连接按钮信号 self.buttonConnect.clicked.connect(self.doConnect) # 绑定拉动信号 self.sliderForward.valueChanged.connect(self.doForward) self.sliderBackward.valueChanged.connect(self.doBackward) self.sliderLeft.valueChanged.connect(self.doLeft) self.sliderRight.valueChanged.connect(self.doRight) # 设置初始拉动条不能用 self.sliderForward.setEnabled(False) self.sliderBackward.setEnabled(False) self.sliderLeft.setEnabled(False) self.sliderRight.setEnabled(False) def closeEvent(self, event): """窗口关闭事件""" if self._conn: self._conn.close() self._conn.deleteLater() del self._conn self._conn = None super(ControlCar, self).closeEvent(event) def doConnect(self): """连接服务器""" self.buttonConnect.setEnabled(False) if self._conn: self._conn.close() self._conn.deleteLater() del self._conn self._conn = None self.browserResult.append('正在连接服务器') self._conn = QTcpSocket(self) self._conn.connected.connect(self.onConnected) # 绑定连接成功信号 self._conn.disconnected.connect(self.onDisconnected) # 绑定连接丢失信号 self._conn.readyRead.connect(self.onReadyRead) # 准备读取信号 self._conn.error.connect(self.onError) # 连接错误信号 self._conn.connectToHost(self.HOST, self.PORT) def onConnected(self): """连接成功""" self.buttonConnect.setEnabled(False) # 按钮不可用 # 设置初始拉动条可用 self.sliderForward.setEnabled(True) self.sliderBackward.setEnabled(True) self.sliderLeft.setEnabled(True) self.sliderRight.setEnabled(True) self.browserResult.append('连接成功') # 记录日志 def onDisconnected(self): """丢失连接""" self.buttonConnect.setEnabled(True) # 按钮可用 # 设置初始拉动条不可用 self.sliderForward.setEnabled(False) self.sliderBackward.setEnabled(False) self.sliderLeft.setEnabled(False) self.sliderRight.setEnabled(False) # 把数据设置为最小值 self.sliderForward.setValue(self.sliderForward.minimum()) self.sliderBackward.setValue(self.sliderBackward.minimum()) self.sliderLeft.setValue(self.sliderLeft.minimum()) self.sliderRight.setValue(self.sliderRight.minimum()) self.browserResult.append('丢失连接') # 记录日志 def onReadyRead(self): """接收到数据""" while self._conn.bytesAvailable() > 0: try: data = self._conn.readAll().data() self.browserResult.append('接收到数据: ' + data.decode()) except Exception as e: self.browserResult.append('解析数据错误: ' + str(e)) def onError(self, _): """连接报错""" self.buttonConnect.setEnabled(True) # 按钮可用 self.browserResult.append('连接服务器错误: ' + self._conn.errorString()) def doForward(self, value): """向前""" # 发送的内容为 F:1 类似的 self.sendData('F:', str(value)) def doBackward(self, value): """向后""" # 发送的内容为 B:1 类似的 self.sendData('B:', str(value)) def doLeft(self, value): """向左""" # 发送的内容为 L:1 类似的 self.sendData('L:', str(value)) def doRight(self, value): """向右""" # 发送的内容为 R:1 类似的 self.sendData('R:', str(value)) def sendData(self, ver, data): """发送数据""" if not self._conn or not self._conn.isWritable(): return self.browserResult.append('服务器未连接或不可写入数据') # self._conn.write(ver.encode() + str(data).encode()) # 我的服务器需要接收以\n结尾的数据 self._conn.write(ver.encode() + str(data).encode() + b'\n')
class ControlCar(QWidget): HOST = '127.0.0.1' PORT = 8888 def __init__(self, *args, **kwargs): super(ControlCar, self).__init__(*args, **kwargs) self._connCar = None # 加载UI文件 uic.loadUi('carui.ui', self) self.resize(800, 600) # 绑定连接按钮信号 self.buttonConnect.clicked.connect(self.doConnect) # 绑定拉动信号 self.sliderForward.valueChanged.connect(self.doForward) self.sliderBackward.valueChanged.connect(self.doBackward) self.sliderLeft.valueChanged.connect(self.doLeft) self.sliderRight.valueChanged.connect(self.doRight) # 设置初始拉动条不能用 self.sliderForward.setEnabled(False) self.sliderBackward.setEnabled(False) self.sliderLeft.setEnabled(False) self.sliderRight.setEnabled(False) # 定时器定时向图片服务器发送请求 self._timer = QTimer(self, timeout=self.doGetImage) def _clearConn(self): """清理连接""" if self._connCar: self._connCar.close() self._connCar.deleteLater() del self._connCar self._connCar = None def closeEvent(self, event): """窗口关闭事件""" self._timer.stop() self._clearConn() super(ControlCar, self).closeEvent(event) def doConnect(self): """连接服务器""" self.buttonConnect.setEnabled(False) self._timer.stop() self._clearConn() self.browserResult.append('正在连接服务器') # 连接控制小车的服务器 self._connCar = QTcpSocket(self) self._connCar.connected.connect(self.onConnected) # 绑定连接成功信号 self._connCar.disconnected.connect(self.onDisconnected) # 绑定连接丢失信号 self._connCar.readyRead.connect(self.onReadyRead) # 准备读取信号 self._connCar.error.connect(self.onError) # 连接错误信号 self._connCar.connectToHost(self.HOST, self.PORT) def onConnected(self): """连接成功""" self.buttonConnect.setEnabled(False) # 按钮不可用 # 设置初始拉动条可用 self.sliderForward.setEnabled(True) self.sliderBackward.setEnabled(True) self.sliderLeft.setEnabled(True) self.sliderRight.setEnabled(True) self.browserResult.append('连接成功') # 记录日志 # 开启获取摄像头图片定时器 self._timer.start(200) def onDisconnected(self): """丢失连接""" self._timer.stop() self.buttonConnect.setEnabled(True) # 按钮可用 # 设置初始拉动条不可用 self.sliderForward.setEnabled(False) self.sliderBackward.setEnabled(False) self.sliderLeft.setEnabled(False) self.sliderRight.setEnabled(False) # 把数据设置为最小值 self.sliderForward.setValue(self.sliderForward.minimum()) self.sliderBackward.setValue(self.sliderBackward.minimum()) self.sliderLeft.setValue(self.sliderLeft.minimum()) self.sliderRight.setValue(self.sliderRight.minimum()) self.browserResult.append('丢失连接') # 记录日志 def onReadyRead(self): """接收到数据""" while self._connCar.bytesAvailable() > 0: try: data = self._connCar.readAll().data() if data and data.find(b'JFIF') > -1: self.qlabel.setPixmap( # 图片 QPixmap.fromImage(QImage.fromData(data))) else: self.browserResult.append('接收到数据: ' + data.decode()) except Exception as e: self.browserResult.append('解析数据错误: ' + str(e)) def onError(self, _): """连接报错""" self._timer.stop() self.buttonConnect.setEnabled(True) # 按钮可用 self.browserResult.append('连接服务器错误: ' + self._connCar.errorString()) def doForward(self, value): """向前""" # 发送的内容为 F:1 类似的 self.sendData('F:', str(value)) def doBackward(self, value): """向后""" # 发送的内容为 B:1 类似的 self.sendData('B:', str(value)) def doLeft(self, value): """向左""" # 发送的内容为 L:1 类似的 self.sendData('L:', str(value)) def doRight(self, value): """向右""" # 发送的内容为 R:1 类似的 self.sendData('R:', str(value)) def doGetImage(self): # 请求图片 self.sendData('getimage', '') def sendData(self, ver, data): """发送数据""" if not self._connCar or not self._connCar.isWritable(): return self.browserResult.append('服务器未连接或不可写入数据') self._connCar.write(ver.encode() + str(data).encode() + b'\n')
class Client(QDialog): def __init__(self, parent=None): super(Client, self).__init__(parent) self.networkSession = None self.blockSize = 0 self.currentFortune = "" hostLabel = QLabel("&Server name:") portLabel = QLabel("S&erver port:") self.hostCombo = QComboBox() self.hostCombo.setEditable(True) name = QHostInfo.localHostName() if name != "": self.hostCombo.addItem(name) domain = QHostInfo.localDomainName() if domain != "": self.hostCombo.addItem(name + "." + domain) if name != "localhost": self.hostCombo.addItem("localhost") ipAddressesList = QNetworkInterface.allAddresses() for ipAddress in ipAddressesList: if not ipAddress.isLoopback(): self.hostCombo.addItem(ipAddress.toString()) for ipAddress in ipAddressesList: if ipAddress.isLoopback(): self.hostCombo.addItem(ipAddress.toString()) self.portLineEdit = QLineEdit() self.portLineEdit.setValidator(QIntValidator(1, 65535, self)) hostLabel.setBuddy(self.hostCombo) portLabel.setBuddy(self.portLineEdit) self.statusLabel = QLabel("This examples requires that you run " "the Fortune Server example as well.") self.getFortuneButton = QPushButton("Get Fortune") self.getFortuneButton.setDefault(True) self.getFortuneButton.setEnabled(False) quitButton = QPushButton("Quit") buttonBox = QDialogButtonBox() buttonBox.addButton(self.getFortuneButton, QDialogButtonBox.ActionRole) buttonBox.addButton(quitButton, QDialogButtonBox.RejectRole) self.tcpSocket = QTcpSocket(self) self.hostCombo.editTextChanged.connect(self.enableGetFortuneButton) self.portLineEdit.textChanged.connect(self.enableGetFortuneButton) self.getFortuneButton.clicked.connect(self.requestNewFortune) quitButton.clicked.connect(self.close) self.tcpSocket.readyRead.connect(self.readFortune) self.tcpSocket.error.connect(self.displayError) mainLayout = QGridLayout() mainLayout.addWidget(hostLabel, 0, 0) mainLayout.addWidget(self.hostCombo, 0, 1) mainLayout.addWidget(portLabel, 1, 0) mainLayout.addWidget(self.portLineEdit, 1, 1) mainLayout.addWidget(self.statusLabel, 2, 0, 1, 2) mainLayout.addWidget(buttonBox, 3, 0, 1, 2) self.setLayout(mainLayout) self.setWindowTitle("Fortune Client") self.portLineEdit.setFocus() manager = QNetworkConfigurationManager() if manager.capabilities() & QNetworkConfigurationManager.NetworkSessionRequired: settings = QSettings(QSettings.UserScope, "QtProject") settings.beginGroup("QtNetwork") id = settings.value("DefaultNetworkConfiguration") settings.endGroup() config = manager.configurationFromIdentifier(id) if config.state() & QNetworkConfiguration.Discovered == 0: config = manager.defaultConfiguration() self.networkSession = QNetworkSession(config, self) self.networkSession.opened.connect(self.sessionOpened) self.getFortuneButton.setEnabled(False) self.statusLabel.setText("Opening network session.") self.networkSession.open() def requestNewFortune(self): self.getFortuneButton.setEnabled(False) self.blockSize = 0 self.tcpSocket.abort() self.tcpSocket.connectToHost(self.hostCombo.currentText(), int(self.portLineEdit.text())) def readFortune(self): instr = QDataStream(self.tcpSocket) instr.setVersion(QDataStream.Qt_4_0) if self.blockSize == 0: if self.tcpSocket.bytesAvailable() < 2: return self.blockSize = instr.readUInt16() if self.tcpSocket.bytesAvailable() < self.blockSize: return nextFortune = instr.readQString() if nextFortune == self.currentFortune: QTimer.singleShot(0, self.requestNewFortune) return self.currentFortune = nextFortune self.statusLabel.setText(self.currentFortune) self.getFortuneButton.setEnabled(True) def displayError(self, socketError): if socketError == QAbstractSocket.RemoteHostClosedError: pass elif socketError == QAbstractSocket.HostNotFoundError: QMessageBox.information( self, "Fortune Client", "The host was not found. Please check the host name and " "port settings." ) elif socketError == QAbstractSocket.ConnectionRefusedError: QMessageBox.information( self, "Fortune Client", "The connection was refused by the peer. Make sure the " "fortune server is running, and check that the host name " "and port settings are correct.", ) else: QMessageBox.information( self, "Fortune Client", "The following error occurred: %s." % self.tcpSocket.errorString() ) self.getFortuneButton.setEnabled(True) def enableGetFortuneButton(self): self.getFortuneButton.setEnabled( (self.networkSession is None or self.networkSession.isOpen()) and self.hostCombo.currentText() != "" and self.portLineEdit.text() != "" ) def sessionOpened(self): config = self.networkSession.configuration() if config.type() == QNetworkConfiguration.UserChoice: id = self.networkSession.sessionProperty("UserChoiceConfiguration") else: id = config.identifier() settings = QSettings(QSettings.UserScope, "QtProject") settings.beginGroup("QtNetwork") settings.setValue("DefaultNetworkConfiguration", id) settings.endGroup() self.statusLabel.setText("This examples requires that you run the " "Fortune Server example as well.") self.enableGetFortuneButton()
class MainFrame(QWidget): def __init__(self, ip='127.0.0.1', port=8888): super().__init__(flags=(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)) print("test: ", Qt.WindowStaysOnTopHint) print("test: ", (Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)) self.q_rect = QDesktopWidget().screenGeometry() self.ip = ip self.port = int(port) self.interval = 15 self.fonts_size = 48 self.danmaku_list = list() self.line_list = [ None for _ in range( 0, self.q_rect.height() // (self.fonts_size + self.interval)) ] self.brush = MyBrush() self.timer = QTimer() self.socket = QTcpSocket(self) self.set_transparent() self.init_ui() self.init_net() self.set_timer() def set_timer(self): self.timer.setInterval(16) self.timer.start() self.timer.timeout.connect(lambda: self.update() if self.danmaku_list else None) def set_transparent(self): self.setAttribute(Qt.WA_TranslucentBackground, True) self.setAttribute(Qt.WA_TransparentForMouseEvents, True) palette = self.palette() palette.setBrush(QPalette.Base, Qt.transparent) self.setPalette(palette) def init_net(self): self.socket.readyRead.connect(self.data_received) self.socket.connected.connect(self.connected) self.socket.connectToHost(self.ip, self.port) def init_ui(self): self.setGeometry(self.q_rect) self.setWindowTitle('Danmaku') self.show() def data_received(self): if self.socket.bytesAvailable() > 0: length = self.socket.bytesAvailable() msg = self.socket.read(length).decode('utf-8') print(msg) if msg[:5] == 'ika__': msg = msg[5:-1] if msg[:-1] != '\n' else msg[5:] danmaku = self.dispatch_line( Message(msg, self.q_rect.width(), 0, self.fonts_size).gen_path()) self.danmaku_list.append(danmaku) def disconnected(self): pass # todo: retry def connected(self): print('connecting...') self.socket.writeData('conn\n'.encode('utf-8')) print(self.socket.state()) def dispatch_line(self, danmaku): planck = self.fonts_size + self.interval for item in self.line_list: if not item: danmaku['path'].translate( 0, planck * (self.line_list.index(item) + 1)) self.line_list[self.line_list.index(item)] = danmaku break else: speed_diff = danmaku['speed'] - item['speed'] distance = self.q_rect.width() - item['path'].currentPosition( ).x() - item['len'] * self.fonts_size print(speed_diff, " dis:", distance) if speed_diff <= 0 < distance: danmaku['path'].translate( 0, planck * (self.line_list.index(item) + 1)) self.line_list[self.line_list.index(item)] = danmaku break return danmaku def paintEvent(self, event): for item in self.danmaku_list[::-1]: self.brush.draw(self, item) now = item['path'].currentPosition().x() + item['path'].length() if now < 0: self.danmaku_list.remove(item) if item in self.line_list: self.line_list[self.line_list.index(item)] = None del item
class Scanner(QMainWindow, Ui_Scanner): def __init__(self): super(Scanner, self).__init__() self.setupUi(self) # IP address validator rx = QRegExp( '^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$' ) self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue)) # state variable self.idle = True # number of samples to show on the plot self.size = 512 * 512 self.freq = 143.0 # buffer and offset for the incoming samples self.buffer = bytearray(8 * self.size) self.offset = 0 self.data = np.frombuffer(self.buffer, np.int32) # create figure figure = Figure() figure.set_facecolor('none') self.axes = figure.add_subplot(111) self.canvas = FigureCanvas(figure) self.plotLayout.addWidget(self.canvas) self.axes.axis((0.0, 512.0, 0.0, 512.0)) x, y = np.meshgrid(np.linspace(0.0, 512.0, 513), np.linspace(0.0, 512.0, 513)) z = x / 512.0 + y * 0.0 self.mesh = self.axes.pcolormesh(x, y, z, cmap=cm.plasma) # create navigation toolbar self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False) # remove subplots action actions = self.toolbar.actions() if int(matplotlib.__version__[0]) < 2: self.toolbar.removeAction(actions[7]) else: self.toolbar.removeAction(actions[6]) self.plotLayout.addWidget(self.toolbar) # create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # connect signals from buttons and boxes self.connectButton.clicked.connect(self.start) self.scanButton.clicked.connect(self.scan) self.periodValue.valueChanged.connect(self.set_period) self.trgtimeValue.valueChanged.connect(self.set_trgtime) self.trginvCheck.stateChanged.connect(self.set_trginv) self.shdelayValue.valueChanged.connect(self.set_shdelay) self.shtimeValue.valueChanged.connect(self.set_shtime) self.shinvCheck.stateChanged.connect(self.set_shinv) self.acqdelayValue.valueChanged.connect(self.set_acqdelay) self.samplesValue.valueChanged.connect(self.set_samples) self.pulsesValue.valueChanged.connect(self.set_pulses) # create timers self.startTimer = QTimer(self) self.startTimer.timeout.connect(self.timeout) self.meshTimer = QTimer(self) self.meshTimer.timeout.connect(self.update_mesh) # set default values self.periodValue.setValue(200.0) def start(self): if self.idle: self.connectButton.setEnabled(False) self.socket.connectToHost(self.addrValue.text(), 1001) self.startTimer.start(5000) else: self.stop() def stop(self): self.idle = True self.socket.abort() self.offset = 0 self.connectButton.setText('Connect') self.connectButton.setEnabled(True) self.scanButton.setEnabled(True) def timeout(self): self.display_error('timeout') def connected(self): self.startTimer.stop() self.idle = False self.set_period(self.periodValue.value()) self.set_trgtime(self.trgtimeValue.value()) self.set_trginv(self.trginvCheck.checkState()) self.set_shdelay(self.shdelayValue.value()) self.set_shtime(self.shtimeValue.value()) self.set_shinv(self.shinvCheck.checkState()) self.set_acqdelay(self.acqdelayValue.value()) self.set_samples(self.samplesValue.value()) self.set_pulses(self.pulsesValue.value()) # start pulse generators self.socket.write(struct.pack('<I', 9 << 28)) self.connectButton.setText('Disconnect') self.connectButton.setEnabled(True) self.scanButton.setEnabled(True) def read_data(self): size = self.socket.bytesAvailable() if self.offset + size < 8 * self.size: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: self.meshTimer.stop() self.buffer[self.offset:8 * self.size] = self.socket.read(8 * self.size - self.offset) self.offset = 0 self.update_mesh() self.scanButton.setEnabled(True) def display_error(self, socketError): self.startTimer.stop() if socketError == 'timeout': QMessageBox.information(self, 'Scanner', 'Error: connection timeout.') else: QMessageBox.information(self, 'Scanner', 'Error: %s.' % self.socket.errorString()) self.stop() def set_period(self, value): # set maximum delays and times to half period maximum = int(value * 5.0 + 0.5) / 10.0 self.trgtimeValue.setMaximum(maximum) self.shdelayValue.setMaximum(maximum) self.shtimeValue.setMaximum(maximum) self.acqdelayValue.setMaximum(maximum) # set maximum number of samples per pulse maximum = int(value * 500.0 + 0.5) / 10.0 if maximum > 256.0: maximum = 256.0 self.samplesValue.setMaximum(maximum) shdelay = value * 0.25 samples = value * 0.5 if self.idle: return self.socket.write(struct.pack('<I', 0 << 28 | int(value * self.freq))) def set_trgtime(self, value): if self.idle: return self.socket.write(struct.pack('<I', 1 << 28 | int(value * self.freq))) def set_trginv(self, checked): if self.idle: return self.socket.write( struct.pack('<I', 2 << 28 | int(checked == Qt.Checked))) def set_shdelay(self, value): if self.idle: return self.socket.write(struct.pack('<I', 3 << 28 | int(value * self.freq))) def set_shtime(self, value): if self.idle: return self.socket.write(struct.pack('<I', 4 << 28 | int(value * self.freq))) def set_shinv(self, checked): if self.idle: return self.socket.write( struct.pack('<I', 5 << 28 | int(checked == Qt.Checked))) def set_acqdelay(self, value): if self.idle: return self.socket.write(struct.pack('<I', 6 << 28 | int(value * self.freq))) def set_samples(self, value): if self.idle: return self.socket.write(struct.pack('<I', 7 << 28 | int(value))) def set_pulses(self, value): if self.idle: return self.socket.write(struct.pack('<I', 8 << 28 | int(value))) def scan(self): if self.idle: return self.scanButton.setEnabled(False) self.data[:] = np.zeros(2 * 512 * 512, np.int32) self.update_mesh() self.socket.write(struct.pack('<I', 10 << 28)) self.meshTimer.start(1000) def update_mesh(self): self.mesh.set_array( self.data[0::2] / (self.samplesValue.value() * self.pulsesValue.value() * 8192.0)) self.canvas.draw()
class SubMachine(QWidget): def __init__(self): super().__init__() self.isUp = False self.port = DEFAULT_PORT self.serverIP = QHostAddress(DEFAULT_ADDR) self.mode = DEFAULT_MODE self.roomTemp = DEFAULT_ROOM_TEMP self.setTemp = DEFAULT_SET_TEMP self.windSpeed = DEFAULT_WIND_SPEED self.energy = 0 self.money = 0 self.room_temp_timer = QTimer() self.energy_timer = QTimer() self.initUi() def initUi(self): self.ui = ui_SubMachine.Ui_Form() self.ui.setupUi(self) self.room_temp_timer.timeout.connect(self.slotUpdateRoomTemp) self.energy_timer.timeout.connect(self.slotUpdateEnergyMoney) self.ui.btClose.clicked.connect(self.slotOpenOrClose) self.ui.btCold.clicked.connect(self.slotColdMode) self.ui.btWarm.clicked.connect(self.slotWarmMode) self.ui.btWindSpeedUp.clicked.connect(self.slotWindSpeedUp) self.ui.btWindSpeedDown.clicked.connect(self.slotWindSpeedDown) self.ui.btSetTempUp.clicked.connect(self.slotSetTempUp) self.ui.btSetTempDown.clicked.connect(self.slotSetTempDown) self.show() def slotUpdateRoomTemp(self): if self.roomTemp != self.setTemp: if self.roomTemp < self.setTemp: self.roomTemp += ROOM_TEMP_INC elif self.roomTemp > self.setTemp: self.roomTemp -= ROOM_TEMP_INC else: # 根据设定温度和模式上下浮动 if self.mode == COLD_MODE: # 室外温度高 self.roomTemp += random.choice([0, 1, 2]) elif self.mode == WARM_MODE: # 室外温度低 self.roomTemp -= random.choice([0, 1, 2]) self.ui.label_roomTemp.setText(str(self.roomTemp)) def slotUpdateEnergyMoney(self): self.energy += ENERGY_INC * self.windSpeed self.money += MONEY_INC * self.windSpeed self.ui.label_energy.setText(str(round(self.energy, 2))) self.ui.label_money.setText(str(round(self.money, 2))) def slotColdMode(self): self.mode = COLD_MODE # send something def slotWarmMode(self): self.mode = WARM_MODE # send something def slotWindSpeedUp(self): if self.windSpeed != HIGH_WIND: self.windSpeed += 1 self.ui.label_windSpeed.setText(mapWindSpeed(self.windSpeed)) # send something def slotWindSpeedDown(self): if self.windSpeed != LOW_WIND: self.windSpeed -= 1 self.ui.label_windSpeed.setText(mapWindSpeed(self.windSpeed)) # send something def slotSetTempUp(self): if self.setTemp != MAX_TEMP: self.setTemp += 1 self.ui.lcd_setTemp.display(self.setTemp) # send something def slotSetTempDown(self): if self.setTemp != MIN_TEMP: self.setTemp -= 1 self.ui.lcd_setTemp.display(self.setTemp) # send something def slotOpenOrClose(self): if self.isUp: self.closeMachine() else: self.openMachine() def closeMachine(self): # send something self.sock.disconnectFromHost() def openMachine(self): self.roomId = self.ui.leRoomId.text() if self.roomId == '': msg = '请先填写房间号!' QMessageBox().warning(self, '房间号为空', msg, QMessageBox.Yes, QMessageBox.Yes) return self.sock = QTcpSocket(self) self.sock.connectToHost(self.serverIP, self.port) self.sock.connected.connect(self.slotConnected) self.sock.readyRead.connect(self.slotDataReceived) self.sock.disconnected.connect(self.slotDisconnected) self.sock.error.connect(self.slotErrorOccured) def slotConnected(self): self.ui.btCold.setEnabled(True) self.ui.btWarm.setEnabled(True) self.ui.btWindSpeedDown.setEnabled(True) self.ui.btWindSpeedUp.setEnabled(True) self.ui.btSetTempDown.setEnabled(True) self.ui.btSetTempUp.setEnabled(True) self.ui.btClose.setText('关机') self.isUp = True self.room_temp_timer.start(ROOM_TEMP_TIMER) self.energy_timer.start(ENERGY_TIMER) # send something def slotDataReceived(self): recvData = b'' while self.sock.bytesAvailable() > 0: recvData += self.sock.read(self.sock.bytesAvailable()) recvData = QJsonDocument().fromJson(recvData) self.parseData(recvData) def parseData(self, recvData): if recvData['type'] == TYPE_REQUEST_STATUS: self.sendStatus() def sendStatus(self): sendData = {'type': TYPE_RESPONSE_STATUS, 'roomId': self.roomId, 'mode': self.mode, 'roomTemp': self.roomTemp, 'setTemp': self.setTemp, 'windSpeed': self.windSpeed, 'energy': self.energy, 'money': self.money} sendData = QJsonDocument(sendData).toJson() self.sock.write(sendData) def slotDisconnected(self): self.ui.btCold.setEnabled(False) self.ui.btWarm.setEnabled(False) self.ui.btWindSpeedDown.setEnabled(False) self.ui.btWindSpeedUp.setEnabled(False) self.ui.btSetTempDown.setEnabled(False) self.ui.btSetTempUp.setEnabled(False) self.ui.btClose.setText('开机') self.room_temp_timer.stop() self.energy_timer.stop() self.isUp = False def slotErrorOccured(self, socketError): if socketError == 0: msg = '请确保中控机开启!' QMessageBox().warning(self, '连接异常', msg, QMessageBox.Yes, QMessageBox.Yes) elif socketError == 1: self.room_temp_timer.stop() self.energy_timer.stop() msg = '与中控机断开连接!' QMessageBox().critical(self, '连接异常', msg, QMessageBox.Yes, QMessageBox.Yes)
def run(self): print('-----------------------') socket = QTcpSocket() count = 0 if not socket.setSocketDescriptor(self.socketId): # 可能是分配的东西,具体作用不知道 # self.emit(SIGNAL("error(int)"), socket.error()) self.error.connect(socket.error) return while socket.state() == QAbstractSocket.ConnectedState: nextBlockSize = 0 stream = QDataStream(socket) stream.setVersion(QDataStream.Qt_5_8) sockeIdToSocketDict[self.socketId] = socket # print(sockeIdToSocketDict) # 将所有连接上来的socket保存起来 # print(fixIdToSocketIdDict) aim_ip = socket.peerAddress().toString() # 获得连上来的IP地址 # print(aim_ip) if (socket.waitForReadyRead() and socket.bytesAvailable() >= SIZEOF_UINT64): print('wait') nextBlockSize = stream.readUInt64() else: print('错误') # 客户端主动断开时,去掉字典中的对应,在这里做一部分操作。 # 客户端主动断开的时候,要将其从self.myParent.sockeIdToSocketDict self.myParent.fixIdToSocketIdDict 中删掉 sockeIdToSocketDict.pop(self.socketId) # 客户端主动断开的时候删掉。 fixIdToSocketIdDict.pop(fixID) threadDict.pop(self.socketId) self.popDeviceSignal.emit(fixID) self.sendError(socket, "Cannot read client request") return if socket.bytesAvailable() < nextBlockSize: print("错误2") if (not socket.waitForReadyRead(60000) or socket.bytesAvailable() < nextBlockSize): self.sendError(socket, "Cannot read client data") return # 这段数据流上 第一个是state 根据state判断接下来的状态, # 发送成功的状态,发送来 success 日期 信号类型 识别结果 识别开始时间 识别时间 state = stream.readQString() # 读状态 print('#61 ' + state) if state == 'successResult': # 如果状态是success,说明下一个发来的是识别的结果 resultBytes = stream.readBytes() try: Thread.lock.lockForRead() finally: Thread.lock.unlock() resultObject = pickle.loads(resultBytes) # print(fixID) # print(resultObject.dateNow) # print(resultObject.kind) # print(resultObject.result) # print(resultObject.startTime) # print(resultObject.usedTime) if resultObject.kind == "HDMI" and self.hdmi_old_result != resultObject.result: # 自动采集的不需要时间,他需要 日期 时间识别结果 发走的信息只有 类型 识别结果 ip地址 全是strhandleSql.pushResultInfo('123425','HDMI','北京卫视','2018-12-23 12:23:21',12) self.pushResultInfoSignal.emit( fixID, resultObject.kind, resultObject.result, resultObject.startTime, int(resultObject.usedTime )) # 发射信号,携带了信号类型,识别结果,aim_ip(当做区分控件的id)结果从这里发出去 self.hdmi_old_result = resultObject.result elif resultObject.kind == 'AV' and self.av_old_result != resultObject.result: self.pushResultInfoSignal.emit( fixID, resultObject.kind, resultObject.result, resultObject.startTime, int(resultObject.usedTime) ) # 发射信号,携带了信号类型,识别结果,aim_ip(当做区分空间的id) getMessgetMessageAllTcpageAllTcp self.av_old_result = resultObject.result elif state == 'sendImage': # 如果状态是wait_to_recognize,说明下一端是图片的16位整数# 图片的暂时不考虑,因为还不知道发给谁 kind = stream.readQString() # 读台标信号类型 try: Thread.lock.lockForRead() finally: Thread.lock.unlock() file = stream.readBytes() with open('image.jpg', 'wb') as f: f.write(file) elif state == 'deviceInfo': # 收到deviceInfo对象 deviceInfoByte = stream.readBytes() try: Thread.lock.lockForRead() finally: Thread.lock.unlock() # pictureSizeByte = stream.readBytes() deviceInfo = pickle.loads(deviceInfoByte) # pictureSize = pickle.loads(pictureSizeByte) fixID = deviceInfo['deviceFixId'] fixIdToSocketIdDict[fixID] = self.socketId print(deviceInfo['pictureSize']) self.pushDeviceInfoSignal.emit(deviceInfo['deviceFixId'], deviceInfo['regionProvince'], deviceInfo['regionCity'], deviceInfo['regionArea']) print("___________________________") print(deviceInfo['fileInfo']) self.pushPictureSizeSignal.emit(str(deviceInfo['pictureSize']), deviceInfo['deviceFixId'], deviceInfo['kind']) self.pushFileInfoSignal.emit(str(deviceInfo['fileInfo']), deviceInfo['deviceFixId']) elif state == 'sendFile': # 准备接受 文件 fileName = stream.readQString() # 读取文件名称 fileSize = stream.readQString() # 读取文件大小 fileBytes = stream.readBytes() # 读取文件部分字节 try: Thread.lock.lockForRead() finally: Thread.lock.unlock() # print(fileSize) with open('../TEST/' + fileName, 'ab') as f: f.write(fileBytes) count = count + fileBytes.__len__()
class MainWindow(QMainWindow): WaitingAnimation = [' |', ' /', ' -', ' \\'] WaitingAnimationFrameDurationMs = 100 ConnectionTimerTimeoutMs = 5000 DataExchangeTimerTimeoutMs = 250 def __init__(self): super().__init__() self.targetAddr = '0.0.0.0' self.targetPort = 0 QSettings.setPath(QSettings.IniFormat, QSettings.UserScope, QDir.currentPath()) self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, 'config') self.readSettings() self.connectionSettings = ConnectionSettings(self.targetAddr, self.targetPort, self) self.connectionSettings.settingsChanged.connect( self.onConnectionSettingsSettingsChanged) self.socket = QTcpSocket(self) self.socket.stateChanged.connect(self.onSocketStateChanged) self.socket.readyRead.connect(self.onSocketReadyRead) self.frameLength = 0 self.lastSocketState = QAbstractSocket.UnconnectedState self.animationTimer = QTimer(self) self.animationTimer.timeout.connect(self.onAnimationTimerTimeout) self.animationCounter = 0 self.connectionTimer = QTimer(self) self.connectionTimer.setSingleShot(True) self.connectionTimer.timeout.connect(self.onConnectionTimerTimeout) self.dataExchangeTimer = QTimer(self) self.dataExchangeTimer.timeout.connect(self.onDataExchangeTimerTimeout) self.initUI() self.onConnectionSettingsSettingsChanged(self.targetAddr, self.targetPort) self.onSocketStateChanged() # self.cap = cv2.VideoCapture(0) # self.dispTimer = QTimer(self) # self.dispTimer.timeout.connect(self.onDispTimerTimeout) # self.dispTimer.start(100) # @pyqtSlot() # def onDispTimerTimeout(self): # ret, frame = self.cap.read() # image = self.cvToQtIm(frame) # pixmap = QPixmap.fromImage(image) # self.streamDisp.setPixmap(pixmap) def initUI(self): self.setGeometry(300, 300, 300, 300) self.setWindowTitle('Diag Tool') statusBar = QStatusBar(self) self.targetInfo = QLabel(self) self.connectionStatus = QLabel(self) statusBar.addWidget(self.targetInfo, 0) statusBar.addWidget(self.connectionStatus, 1) self.setStatusBar(statusBar) self.streamDisp = QLabel(self) self.streamDisp.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) layout = QGridLayout(self) layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(self.streamDisp, 0, 0, 0, 4) self.setCentralWidget(QWidget(self)) self.centralWidget().setLayout(layout) self.menuTarget = self.menuBar().addMenu('Target') self.menuTargetConnect = QAction('Connect', self) self.menuTargetConnect.triggered.connect(self.onMenuTargetConnect) self.menuTargetSettings = QAction('Settings', self) self.menuTargetSettings.triggered.connect(self.onMenuTargetSettings) self.menuTarget.addAction(self.menuTargetConnect) self.menuTarget.addAction(self.menuTargetSettings) def closeEvent(self, event): self.writeSettings() def cvToQtIm(self, cvIm): cvIm = cv2.cvtColor(cvIm, cv2.COLOR_BGR2RGB) return QImage(cvIm.data, cvIm.shape[1], cvIm.shape[0], QImage.Format_RGB888) def readSettings(self): value = self.settings.value('target/addr') if value: self.targetAddr = str(value) value = self.settings.value('target/port') if value: self.targetPort = int(value) def writeSettings(self): self.settings.setValue('target/addr', self.targetAddr) self.settings.setValue('target/port', self.targetPort) @pyqtSlot() def onMenuTargetConnect(self): if QAbstractSocket.UnconnectedState == self.socket.state(): self.menuTargetConnect.setEnabled(False) self.connectionSettings.setUserInputEnabled(False) self.socket.connectToHost(QHostAddress(self.targetAddr), self.targetPort) self.connectionTimer.start(self.ConnectionTimerTimeoutMs) elif QAbstractSocket.ConnectedState == self.socket.state(): self.menuTargetConnect.setEnabled(False) self.socket.disconnectFromHost() @pyqtSlot() def onMenuTargetSettings(self): self.connectionSettings.show() @pyqtSlot() def onSocketStateChanged(self): #print(self.socket.state()) if QAbstractSocket.UnconnectedState == self.socket.state(): self.dataExchangeTimer.timeout.emit() self.dataExchangeTimer.start(self.DataExchangeTimerTimeoutMs) self.animationTimer.stop() self.menuTargetConnect.setText('Connect') self.menuTargetConnect.setEnabled(True) self.connectionStatus.setText('Offline') self.connectionSettings.setUserInputEnabled(True) if QAbstractSocket.ConnectingState == self.lastSocketState: QMessageBox.warning(self, 'Warning', 'Unable to connect!') elif QAbstractSocket.ConnectedState == self.socket.state(): self.connectionTimer.stop() self.animationTimer.stop() self.dataExchangeTimer.start() self.menuTargetConnect.setText('Disconnect') self.menuTargetConnect.setEnabled(True) self.connectionStatus.setText('Online') elif QAbstractSocket.ConnectingState == self.socket.state(): self.connectionStatus.setText('Connecting') self.animationCounter = 0 self.animationTimer.start(self.WaitingAnimationFrameDurationMs) elif QAbstractSocket.ClosingState == self.socket.state(): self.connectionStatus.setText('Disconnecting') self.animationCounter = 0 self.animationTimer.start(self.WaitingAnimationFrameDurationMs) self.lastSocketState = self.socket.state() @pyqtSlot() def onSocketReadyRead(self): if 0 == self.frameLength: if self.socket.canReadLine(): data = self.socket.readLine()[:-1] self.frameLength = int(data) if self.frameLength != 0: if self.socket.bytesAvailable() >= self.frameLength: data = self.socket.read(self.frameLength) arr = np.frombuffer(data, dtype=np.uint8) cvIm = cv2.imdecode(arr, cv2.IMREAD_COLOR) self.frameLength = 0 image = self.cvToQtIm(cvIm) pixmap = QPixmap.fromImage(image) self.streamDisp.setPixmap(pixmap) @pyqtSlot(str, int) def onConnectionSettingsSettingsChanged(self, addr, port): self.targetInfo.setText('Target (' + addr + ':' + str(port) + ')') self.targetAddr = addr self.targetPort = port @pyqtSlot() def onAnimationTimerTimeout(self): if QAbstractSocket.ConnectingState == self.socket.state(): text = 'Connecting' else: text = 'Disconnecting' text += self.WaitingAnimation[self.animationCounter] self.animationCounter = (self.animationCounter + 1) % len( self.WaitingAnimation) self.connectionStatus.setText(text) @pyqtSlot() def onConnectionTimerTimeout(self): self.socket.abort() @pyqtSlot() def onDataExchangeTimerTimeout(self): if QAbstractSocket.ConnectedState == self.socket.state(): self.socket.writeData('get\n'.encode())
class Crossing(QWidget): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Výroba ovládacích prvků self.connectButton = QPushButton(self, text="Start") self.connectButton.clicked.connect(self.connect) self.disconnectButton = QPushButton(self, text="Stop") self.disconnectButton.clicked.connect(self.disconnect) # Rozložení ovládacích prvků self.layout = QVBoxLayout(self) self.layout.addWidget(self.connectButton) self.layout.addWidget(self.disconnectButton) # Příprava TCP socketu self.socket = QTcpSocket(self) self.socket.readyRead.connect(self.read) self.socket.connected.connect(self.connected) self.readBuffer = bytearray() self.travellers = {} # Zobrazení self.setLayout(self.layout) self.show() def disconnect(self): self.socket.write("BYE\n".encode()) def connect(self): # Nejdřív se odpoj, # pokud už spojení běží self.socket.abort() # A znovu se připoj self.socket.connectToHost("ksp.mff.cuni.cz", 48888) def connected(self): # Pozdravíme server self.socket.write("HELLO\n".encode()) def read(self): # Přečteme všechno, co jsme dostali while self.socket.bytesAvailable() > 0: self.readBuffer += self.socket.read(128) # Rozdělíme na řádky lines = self.readBuffer.split(b"\n") # Zbytek uložíme na příště self.readBuffer = lines.pop() # Zpracujeme řádky, které dorazily for l in lines: stripped = l.decode().rstrip() args = stripped.split(" ") travellerType = args.pop(0) argmap = dict(map(lambda x: x.split("="), args)) if travellerType == "CAR": self.addTraveller(Car(**argmap)) elif travellerType == "PEDESTRIAN": self.addTraveller(Pedestrian(**argmap)) def addTraveller(self, traveller): # Uložíme si cestovatele self.travellers[traveller.id] = traveller # Nechť cestovatel vstoupí do oblasti traveller.start(self) def sendBack(self, traveller): # Cestovatel opouští sledovanou oblast self.travellers[traveller.id] = None # Vrátíme cestovatele serveru text = str(traveller) + "\n" self.socket.write(text.encode())
class Client(QDialog): def __init__(self): super().__init__() playbtn = QPushButton('Send', self) playbtn.resize(50, 32) playbtn.move(10, 10) playbtn.clicked.connect(self.send_msg) self.label = QLabel("Received Messages from Server appear here") self.label.setWordWrap(1) self.textbox = QLineEdit(self) self.textbox.move(10, 50) self.textbox.resize(50, 32) layout = QVBoxLayout() layout.addWidget(self.label) layout.addWidget(self.textbox) layout.addWidget(playbtn) self.setLayout(layout) self.resize(600, 100) print('Enter your name:') self.name = input() self.setWindowTitle("Client " + self.name) self.tcpSocket = QTcpSocket(self) self.blockSize = 0 print("Enter server (open ip): Enter for using local host") aaa = input() if len(aaa) == 0: self.ip = '127.0.0.1' else: self.ip = aaa self.makeRequest() self.tcpSocket.readyRead.connect(self.dealCommunication) self.tcpSocket.error.connect(self.displayError) # send start message: self.tcpSocket.waitForConnected(1000) self.tcpSocket.write( bytes(self.name + "," + "Server please init me with my name", encoding='ascii')) def send_msg(self): print("inside send_msg") self.tcpSocket.waitForConnected(1000) self.tcpSocket.write( bytes(self.name + "," + self.textbox.text(), encoding='ascii')) def makeRequest(self): HOST = self.ip # for online use e.g. from server 192.144.178.26 PORT = 8000 self.tcpSocket.connectToHost(HOST, PORT, QIODevice.ReadWrite) def dealCommunication(self): instr = QDataStream(self.tcpSocket) instr.setVersion(QDataStream.Qt_5_0) #print(instr, self.blockSize, self.tcpSocket.bytesAvailable()) if self.blockSize == 0: if self.tcpSocket.bytesAvailable() < 2: return self.blockSize = instr.readUInt16() if self.tcpSocket.bytesAvailable() < self.blockSize: return # Print response to terminal, we could use it anywhere else we wanted. self.label.setText(self.label.text() + "\n" + str(instr.readString(), encoding='ascii')) self.blockSize = 0 def displayError(self, socketError): if socketError == QAbstractSocket.RemoteHostClosedError: pass else: print( self, "The following error occurred: %s." % self.tcpSocket.errorString())
class SmartHubComm(QObject): new_inouts = pyqtSignal(list, list, list, list, list, list, name = 'new_smhub_inouts') new_fullblock = pyqtSignal(str, name = 'new_smhub_raw') def __init__(self, parent=None): super(SmartHubComm, self).__init__(parent) self.smarthubIP = '198.17.154.164' self.router_dim = 20 self.min_smhub_status_size = 1000 self.msg_total = 0 self.smhub_status_block = "" self.raw_model_string = "" self.this_is_set_smhub_phase = False self.inportl = list(range(self.router_dim)) self.inlabell = ["Unknown"] * self.router_dim self.outportl = list(range(self.router_dim)) self.outlabell = ["Unknown"] * self.router_dim self.routein = list(range(self.router_dim)) self.routeout = list(range(self.router_dim)) self.new_fullblock.connect(self.parse_hub_data) self.new_inouts.connect(self.on_shdata_parsed) self.invoke_query_of_smhub() def invoke_query_of_smhub(self): self.sock = QTcpSocket() self.sock.error.connect(self.on_tcp_error) self.sock.readyRead.connect(self.on_ready_read) try: self.sock.connectToHost(self.smarthubIP, 9990) if not self.sock.waitForConnected(1000): errstr = "Error Communicating with SmartHub" print(errstr) except: print(self.sock.SocketError()) def on_shdata_parsed(self,inportl, inlabell, outportl, outlabell, routein, routeout): self.inportl = inportl self.inlabell = inlabell self.outportl = outportl self.outlabell = outlabell, self.routein = routein self.routeout = routeout def get_smhub_inouts(self): return(self.inportl, self.inlabell, self.outportl, self.outlabell, self.routein, self.routeout) def on_ready_read(self): instream = QTextStream(self.sock) inblock = () bytes_avail = self.sock.bytesAvailable() inblock = instream.readAll() self.smhub_status_block += inblock self.msg_total = self.msg_total + bytes_avail if self.msg_total >= self.min_smhub_status_size: self.sock.close() self.new_fullblock.emit(self.smhub_status_block) def parse_hub_data(self, fullblock): blocklist = () blocklist = fullblock.split('\n') ila = []; ola = []; vra = []; inportl = []; inlabell = [] outportl = []; outlabell = []; routein = []; routeout = [] modre = re.compile('^Model name') ilre = re.compile('^INPUT LABELS:$') olre = re.compile('^OUTPUT LABELS:$') vore = re.compile('^VIDEO OUTPUT ROUTING:$') modind = [i for i, item in enumerate (blocklist) if modre.match(item)][0] self.raw_model_string = str(blocklist[modind]) #print("Smarthub model:",self.raw_model_string) # Find lines starting the input label list, output label list, and routing list ilind = [i for i, item in enumerate (blocklist) if ilre.match(item)][0] olind = [i for i, item in enumerate (blocklist) if olre.match(item)][0] voind = [i for i, item in enumerate (blocklist) if vore.match(item)][0] # Read in the input and output label blocks, and the routing list for i in range((ilind+1), (ilind+(self.router_dim+1))): ila.append(blocklist[i]) for i in range((olind+1), (olind+(self.router_dim+1))): ola.append(blocklist[i]) # The routing list is just two numbers (input port and matched output port). for i in range((voind+1), (voind+(self.router_dim+1))): vra.append(blocklist[i]) # Parse the label lists and populate a data structure to hold the labels for i in range(0, len(ila) ): line = ila[i] #print line try: [port, label] = filter(None, line.split(' ')) except: try: [port, label1, label2] = line.split(' ') label = label1 + " " + label2 except: try: [port, label1, label2, label3] = line.split(' ') label = label1 + " " + label2 + " " + label3 except: [port, label1, label2, label3, label4] = line.split(' ') label = label1 + " " + label2 + " " + label3 + " " + label4 inportl.append(port) inlabell.append(label) for i in range(0, len(ola) ): line = ola[i] #print line try: [port, label] = filter(None, line.split(' ')) except: try: [port, label1, label2] = line.split(' ') label = label1 + " " + label2 except: try: [port, label1, label2, label3] = line.split(' ') label = label1 + " " + label2 + " " + label3 except: [port, label1, label2, label3, label4] = line.split(' ') label = label1 + " " + label2 + " " + label3 + " " + label4 outportl.append(port) outlabell.append(label) for i in range(0, len(vra) ): line = vra[i] try: [outport, inport] = line.split(' ') inport = int(inport) outport = int(outport) except: print("Failed to parse route line %d") % (i) routein.append(inport) routeout.append(outport) #print(routeout) self.new_inouts.emit(inportl, inlabell, outportl, outlabell, routein, routeout) def on_tcp_error(self, connect_error): if connect_error == QAbstractSocket.RemoteHostClosedError: print("ERROR: Remote host closed") elif connect_error == QAbstractSocket.HostNotFoundError: print("ERROR: Host was not found") elif connect_error == QAbstractSocket.ConnectionRefusedError: print("ERROR: The connection was refused by the peer") else: print("The following error occurred: %l" % self.sock.errorString()) def get_smarthub_model(self): return self.raw_model_string
class TcpClient(QtCore.QThread): socketlist = [] socketInfo = {} signRecv = QtCore.pyqtSignal(str) signLog = QtCore.pyqtSignal(str) signFileBtn = QtCore.pyqtSignal(int) signFileBar = QtCore.pyqtSignal(int, int) signThread = QtCore.pyqtSignal(str, int, int, "QByteArray") signConfirm = QtCore.pyqtSignal(str) signFileSpeed = QtCore.pyqtSignal(str, str) def __init__(self, parent=None): super(TcpClient, self).__init__(parent) self.blockBytes = FileBlockSize # self.bytesReceive=0 self.fileBytes = 0 self.headSize = 0 self.flag = False # self.sendInit() self.signThread.connect(self.sendFile) self.signConfirm.connect(self.sendFileConfirm) def isconnect(self, ip): if ip in self.socketlist: return True return False def setIpPort(self, ip, port, ids, msgtype, msg): self.server_ip = ip self.server_port = port self.filename = msg self.msgtype = msgtype self.id = ids def slotTcpSendMsg(self, ips, ports, ids, types, msgs): # print("tcpclient send msg:",ips,ports,types,msgs) self.setIpPort(ips, ports, ids, types, msgs) if not self.isconnect(ips): self.tcpSocket = QTcpSocket() self.tcpSocket.connected.connect(self.connected) self.tcpSocket.readyRead.connect(self.readMessage) self.tcpSocket.error.connect(self.connError) self.tcpSocket.connectToHost(self.server_ip, int(self.server_port)) log_content = "connect to %s:%s ..." % (self.server_ip, self.server_port) self.signLog.emit(log_content) if not self.tcpSocket.waitForConnected(500): msg = self.tcpSocket.errorString() self.signLog.emit(msg) self.closeConnect() self.signFileBtn.emit(1) return self.socketlist.append(ips) self.socketInfo[ips] = self.tcpSocket return if ips in self.socketInfo.keys(): self.tcpSocket = self.socketInfo[ips] self.sendMessage() def connError(self): self.signLog.emit("connect error") self.closeConnect() def connected(self): self.sendMessage() def sendLocalMsg(self, filename): # self.sendInit() qheaer = self.getHeaderMsg(filename) self.sendHeaderMsg(qheaer) # self.sendInit() def sendMessage(self): if self.msgtype == 1: self.sendLocalMsg(self.filename) elif self.msgtype == 2: # log_content="connected,start to send file" # self.signLog.emit(log_content) self.sendMsgFile(self.filename) def sendMsgFile(self, filename): self.flag = True crthread = threading.Thread(target=self.readFile, args=(filename, self.blockBytes)) crthread.daemon = True # 设置随主线程退出 crthread.start() self.flag = False def readFile(self, filename, blockbytes): # print("send file",filename) info = QtCore.QFileInfo(filename) fname = info.fileName() localfile = QtCore.QFile(filename) localfile.open(QtCore.QFile.ReadOnly) totalFBytes = localfile.size() filecont = QByteArray() # filecont = self.localfile.read(min(totalFBytes,self.blockBytes)) fstream = QDataStream(localfile) fnum = math.ceil(float(totalFBytes) / self.blockBytes) # print("total",totalFBytes) # print("blockbytes",self.blockBytes) # print("fnum",fnum) i = 0 start_time = int(time.time()) tmp_time = start_time tmp_speed = "" tmp_total_time = "" while not fstream.atEnd(): readsize = min(totalFBytes, self.blockBytes) totalFBytes -= readsize filecont = fstream.readRawData(readsize) # print("send",i,readsize) self.signThread.emit(fname, i, readsize, filecont) i += 1 self.signFileBar.emit(fnum, i) self.flag = True while self.flag: if len(tmp_speed) > 0: self.signFileSpeed.emit(time_total_time + "s", self.getRandomTime(tmp_speed)) time.sleep(0.5) now_time = int(time.time()) about_time, speed = self.getAboutTime(now_time - tmp_time + 0.1, readsize, totalFBytes) self.signFileSpeed.emit(about_time + "s", speed) tmp_time = now_time tmp_speed = speed time_total_time = about_time localfile.close() self.signFileBar.emit(fnum, fnum) now_time = int(time.time()) ab_time = self.getTimeFromat(now_time - start_time) + "s" self.signFileSpeed.emit(ab_time, "") self.signConfirm.emit(fname) def getRandomTime(self, speed): increment = random.randint(-2, 3) increment_dot = random.randint(-5, 8) speeds = "" if 'MB' in speed: speeds = str(float(speed[:-2]) + increment * 0.1) + "MB" elif 'KB' in speed: speeds = str( float(speed[:-2]) + increment * 2 + increment_dot * 0.05) + "KB" elif 'B' in speed: speeds = str(float(speed[:-1]) + increment) + "B" return speeds def getAboutTime(self, timespan, readsize, totalsize): speed = round(readsize / timespan, 2) if timespan == 0.1: speed /= 10 about_time = int(totalsize / speed) sp_unit = "B" if speed >= 1024: sp_unit = "KB" speed = round(speed / 1024, 2) if speed >= 1024: sp_unit = "MB" speed = round(speed / 1024, 2) ab_result = self.getTimeFromat(about_time) sp_result = str(speed) + sp_unit return ab_result, sp_result def getTimeFromat(self, about_time): ab_unit = [] if about_time >= 60: ab_unit.append(str(about_time % 60)) about_time = int(about_time / 60) if about_time >= 60: ab_unit.append(str(about_time % 60)) about_time = int(about_time / 60) ab_unit.append(str(about_time)) tmp_ab = ab_unit[::-1] ab_result = ':'.join(tmp_ab) return ab_result def sendConfirm(self): qheaer = self.confirmHeader() self.sendHeaderMsg(qheaer) def sendFileConfirm(self, fname): qheaer = self.confirmHeader(3, fname) self.sendHeaderMsg(qheaer) def readMessage(self): stream = QDataStream(self.tcpSocket) stream.setVersion(QDataStream.Qt_5_4) while self.tcpSocket.bytesAvailable() > SIZEOF_HEAD_INT: if self.headSize == 0: self.headSize = stream.readInt64() # fileBytes=stream.readInt64() # self.bytesReceive+=SIZEOF_HEAD_INT if self.tcpSocket.bytesAvailable() >= self.headSize: qheader = stream.readQString() # print("client recv head:",qheader) # self.bytesReceive += self.headSize self.handlerMessage(qheader) self.initRecv() else: break def handlerMessage(self, headers): if len(headers) < 1: return headStr = json.loads(headers) type = 0 if "type" in headStr: type = headStr["type"] if type == 3: if "status" in headStr and headStr["status"] == 0: self.flag = False # self.closeConnect()#断开连接 def sendFile(self, fname, fnum, filelen, filecont): self.sendInit() qheader = self.getHeader(fname, filelen, fnum, 2) self.sendmsg(qheader, filecont) # self.sendInit() def sendmsg(self, qheader, filecont): self.outBlock = QByteArray() sendout = QDataStream(self.outBlock, QIODevice.WriteOnly) sendout.setVersion(QDataStream.Qt_5_4) sendout.writeInt64(0) #占位 sendout.writeInt64(0) sendout.writeQString(qheader) headBytes = self.outBlock.size() sendout.writeRawData(filecont) fileBytes = self.outBlock.size() - headBytes sendout.device().seek(0) sendout.writeInt64(headBytes - SIZEOF_HEAD_INT) sendout.writeInt64(fileBytes) self.tcpSocket.write(self.outBlock) #head def sendHeaderMsg(self, qheader): self.outBlock = QByteArray() sendout = QDataStream(self.outBlock, QIODevice.WriteOnly) sendout.setVersion(QDataStream.Qt_5_4) sendout.writeInt64(0) #占位 sendout.writeInt64(0) sendout.writeQString(qheader) headBytes = self.outBlock.size() sendout.device().seek(0) sendout.writeInt64(headBytes - SIZEOF_HEAD_INT) self.tcpSocket.write(self.outBlock) #head def closeConnect(self): log_content = "client disconnect to %s" % (self.server_ip) self.signLog.emit(log_content) self.tcpSocket.disconnectFromHost() self.tcpSocket.close() # self.sign.emit(1) def initRecv(self): self.headSize = 0 def sendInit(self): # print("client sent init") self.fileBytes = 0 # self.flag=False def getHeader(self, fname, flen, fnum, type=0): data = {} data["type"] = type data["id"] = self.id data["filename"] = fname data["filelen"] = flen data["fnum"] = fnum strs = json.dumps(data) return _fromUtf8(strs) def confirmHeader(self, type=3, fname=""): data = {} data["type"] = type data["id"] = self.id data["confirm"] = "send" data["status"] = 0 if fname != "": data["filename"] = fname strs = json.dumps(data) return _fromUtf8(strs) def getHeaderMsg(self, contant): data = {} data["type"] = 1 data["msg"] = contant data["id"] = self.id strs = json.dumps(data) return _fromUtf8(strs)
class VNA(QMainWindow, Ui_VNA): max_size = 16383 formatter = matplotlib.ticker.FuncFormatter(lambda x, pos: '%1.1fM' % (x * 1e-6) if abs(x) >= 1e6 else '%1.1fk' % (x * 1e-3) if abs(x) >= 1e3 else '%1.1f' % x if abs(x) >= 1e0 else '%1.1fm' % (x * 1e+3) if abs(x) >= 1e-3 else '%1.1fu' % (x * 1e+6) if abs(x) >= 1e-6 else '%1.1f' % x) def __init__(self): super(VNA, self).__init__() self.setupUi(self) # IP address validator rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$') self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue)) # state variable self.idle = True # sweep parameters self.sweep_start = 100 self.sweep_stop = 60000 self.sweep_size = 600 self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True) self.xaxis *= 1000 # buffer and offset for the incoming samples self.buffer = bytearray(32 * VNA.max_size) self.offset = 0 self.data = np.frombuffer(self.buffer, np.complex64) self.adc1 = np.zeros(VNA.max_size, np.complex64) self.adc2 = np.zeros(VNA.max_size, np.complex64) self.dac1 = np.zeros(VNA.max_size, np.complex64) self.open = np.zeros(VNA.max_size, np.complex64) self.short = np.zeros(VNA.max_size, np.complex64) self.load = np.zeros(VNA.max_size, np.complex64) self.dut = np.zeros(VNA.max_size, np.complex64) self.mode = 'dut' # create figure self.figure = Figure() self.figure.set_facecolor('none') self.canvas = FigureCanvas(self.figure) self.plotLayout.addWidget(self.canvas) # create navigation toolbar self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False) # remove subplots action actions = self.toolbar.actions() self.toolbar.removeAction(actions[7]) self.plotLayout.addWidget(self.toolbar) # create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # connect signals from buttons and boxes self.sweepFrame.setEnabled(False) self.dutSweep.setEnabled(False) self.connectButton.clicked.connect(self.start) self.writeButton.clicked.connect(self.write_cfg) self.readButton.clicked.connect(self.read_cfg) self.openSweep.clicked.connect(self.sweep_open) self.shortSweep.clicked.connect(self.sweep_short) self.loadSweep.clicked.connect(self.sweep_load) self.dutSweep.clicked.connect(self.sweep_dut) self.s1pButton.clicked.connect(self.write_s1p) self.startValue.valueChanged.connect(self.set_start) self.stopValue.valueChanged.connect(self.set_stop) self.sizeValue.valueChanged.connect(self.set_size) self.openPlot.clicked.connect(self.plot_open) self.shortPlot.clicked.connect(self.plot_short) self.loadPlot.clicked.connect(self.plot_load) self.dutPlot.clicked.connect(self.plot_dut) self.smithPlot.clicked.connect(self.plot_smith) self.impPlot.clicked.connect(self.plot_imp) self.rcPlot.clicked.connect(self.plot_rc) self.swrPlot.clicked.connect(self.plot_swr) self.rlPlot.clicked.connect(self.plot_rl) # create timer self.startTimer = QTimer(self) self.startTimer.timeout.connect(self.timeout) def start(self): if self.idle: self.connectButton.setEnabled(False) self.socket.connectToHost(self.addrValue.text(), 1001) self.startTimer.start(5000) else: self.stop() def stop(self): self.idle = True self.socket.abort() self.offset = 0 self.connectButton.setText('Connect') self.connectButton.setEnabled(True) self.sweepFrame.setEnabled(False) self.selectFrame.setEnabled(True) self.dutSweep.setEnabled(False) def timeout(self): self.display_error('timeout') def connected(self): self.startTimer.stop() self.idle = False self.set_start(self.startValue.value()) self.set_stop(self.stopValue.value()) self.set_size(self.sizeValue.value()) self.connectButton.setText('Disconnect') self.connectButton.setEnabled(True) self.sweepFrame.setEnabled(True) self.dutSweep.setEnabled(True) def read_data(self): size = self.socket.bytesAvailable() if self.offset + size < 32 * self.sweep_size: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: self.buffer[self.offset:32 * self.sweep_size] = self.socket.read(32 * self.sweep_size - self.offset) self.offset = 0 self.adc1 = self.data[0::4] self.adc2 = self.data[1::4] self.dac1 = self.data[2::4] getattr(self, self.mode)[0:self.sweep_size] = self.adc1[0:self.sweep_size] / self.dac1[0:self.sweep_size] self.sweepFrame.setEnabled(True) self.selectFrame.setEnabled(True) getattr(self, 'plot_%s' % self.mode)() def display_error(self, socketError): self.startTimer.stop() if socketError == 'timeout': QMessageBox.information(self, 'VNA', 'Error: connection timeout.') else: QMessageBox.information(self, 'VNA', 'Error: %s.' % self.socket.errorString()) self.stop() def set_start(self, value): self.sweep_start = value self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True) self.xaxis *= 1000 if self.idle: return self.socket.write(struct.pack('<I', 0<<28 | int(value * 1000))) def set_stop(self, value): self.sweep_stop = value self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True) self.xaxis *= 1000 if self.idle: return self.socket.write(struct.pack('<I', 1<<28 | int(value * 1000))) def set_size(self, value): self.sweep_size = value self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True) self.xaxis *= 1000 if self.idle: return self.socket.write(struct.pack('<I', 2<<28 | int(value))) def sweep(self): if self.idle: return self.sweepFrame.setEnabled(False) self.selectFrame.setEnabled(False) self.socket.write(struct.pack('<I', 3<<28)) def sweep_open(self): self.mode = 'open' self.sweep() def sweep_short(self): self.mode = 'short' self.sweep() def sweep_load(self): self.mode = 'load' self.sweep() def sweep_dut(self): self.mode = 'dut' self.sweep() def impedance(self): return 50.0 * (self.open[0:self.sweep_size] - self.load[0:self.sweep_size]) * (self.dut[0:self.sweep_size] - self.short[0:self.sweep_size]) / ((self.load[0:self.sweep_size] - self.short[0:self.sweep_size]) * (self.open[0:self.sweep_size] - self.dut[0:self.sweep_size])) def gamma(self): z = self.impedance() return (z - 50.0)/(z + 50.0) def plot_magphase(self, data): matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(top = 0.98, right = 0.88) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(VNA.formatter) axes1.yaxis.set_major_formatter(VNA.formatter) axes1.tick_params('y', color = 'blue', labelcolor = 'blue') axes1.yaxis.label.set_color('blue') axes1.plot(self.xaxis, np.absolute(data), color = 'blue') axes2 = axes1.twinx() axes2.spines['left'].set_color('blue') axes2.spines['right'].set_color('red') axes1.set_xlabel('Hz') axes1.set_ylabel('Magnitude') axes2.set_ylabel('Phase angle') axes2.tick_params('y', color = 'red', labelcolor = 'red') axes2.yaxis.label.set_color('red') axes2.plot(self.xaxis, np.angle(data, deg = True), color = 'red') self.canvas.draw() def plot_open(self): self.plot_magphase(self.open[0:self.sweep_size]) def plot_short(self): self.plot_magphase(self.short[0:self.sweep_size]) def plot_load(self): self.plot_magphase(self.load[0:self.sweep_size]) def plot_dut(self): self.plot_magphase(self.dut[0:self.sweep_size]) def plot_smith(self): matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(top = 0.90, right = 0.90) axes = self.figure.add_subplot(111, projection = 'smith', axes_radius = 0.55, axes_scale = 50.0) axes.cla() axes.plot(self.impedance()) self.canvas.draw() def plot_imp(self): self.plot_magphase(self.impedance()) def plot_rc(self): self.plot_magphase(self.gamma()) def plot_swr(self): matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(top = 0.98, right = 0.88) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(VNA.formatter) axes1.yaxis.set_major_formatter(VNA.formatter) axes1.set_xlabel('Hz') axes1.set_ylabel('SWR') magnitude = np.absolute(self.gamma()) swr = np.maximum(1.0, np.minimum(100.0, (1.0 + magnitude) / np.maximum(1.0e-20, 1.0 - magnitude))) axes1.plot(self.xaxis, swr, color = 'blue') self.canvas.draw() def plot_rl(self): matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(top = 0.98, right = 0.88) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(VNA.formatter) axes1.set_xlabel('Hz') axes1.set_ylabel('Return loss, dB') magnitude = np.absolute(self.gamma()) axes1.plot(self.xaxis, 20.0 * np.log10(magnitude), color = 'blue') self.canvas.draw() def write_cfg(self): name = QFileDialog.getSaveFileName(self, 'Write configuration settings', '.', '*.ini') settings = QSettings(name[0], QSettings.IniFormat) self.write_cfg_settings(settings) def read_cfg(self): name = QFileDialog.getOpenFileName(self, 'Read configuration settings', '.', '*.ini') settings = QSettings(name[0], QSettings.IniFormat) self.read_cfg_settings(settings) def write_cfg_settings(self, settings): settings.setValue('start', self.startValue.value()) settings.setValue('stop', self.stopValue.value()) size = self.sizeValue.value() settings.setValue('size', size) for i in range(0, size): settings.setValue('open_real_%d' % i, float(self.open.real[i])) settings.setValue('open_imag_%d' % i, float(self.open.imag[i])) for i in range(0, size): settings.setValue('short_real_%d' % i, float(self.short.real[i])) settings.setValue('short_imag_%d' % i, float(self.short.imag[i])) for i in range(0, size): settings.setValue('load_real_%d' % i, float(self.load.real[i])) settings.setValue('load_imag_%d' % i, float(self.load.imag[i])) for i in range(0, size): settings.setValue('dut_real_%d' % i, float(self.dut.real[i])) settings.setValue('dut_imag_%d' % i, float(self.dut.imag[i])) def read_cfg_settings(self, settings): self.startValue.setValue(settings.value('start', 100, type = int)) self.stopValue.setValue(settings.value('stop', 60000, type = int)) size = settings.value('size', 600, type = int) self.sizeValue.setValue(size) for i in range(0, size): real = settings.value('open_real_%d' % i, 0.0, type = float) imag = settings.value('open_imag_%d' % i, 0.0, type = float) self.open[i] = real + 1.0j * imag for i in range(0, size): real = settings.value('short_real_%d' % i, 0.0, type = float) imag = settings.value('short_imag_%d' % i, 0.0, type = float) self.short[i] = real + 1.0j * imag for i in range(0, size): real = settings.value('load_real_%d' % i, 0.0, type = float) imag = settings.value('load_imag_%d' % i, 0.0, type = float) self.load[i] = real + 1.0j * imag for i in range(0, size): real = settings.value('dut_real_%d' % i, 0.0, type = float) imag = settings.value('dut_imag_%d' % i, 0.0, type = float) self.dut[i] = real + 1.0j * imag def write_s1p(self): name = QFileDialog.getSaveFileName(self, 'Write s1p file', '.', '*.s1p') fh = open(name[0], 'w') gamma = self.gamma() size = self.sizeValue.value() fh.write('# GHz S MA R 50\n') for i in range(0, size): fh.write('0.0%.8d %8.6f %7.2f\n' % (self.xaxis[i], np.absolute(gamma[i]), np.angle(gamma[i], deg = True))) fh.close()
class PulsedNMR(QMainWindow, Ui_PulsedNMR): rates = {0:25.0e3, 1:50.0e3, 2:250.0e3, 3:500.0e3, 4:2500.0e3} def __init__(self): super(PulsedNMR, self).__init__() self.setupUi(self) self.rateValue.addItems(['25', '50', '250', '500', '2500']) # IP address validator rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$') self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue)) # state variable self.idle = True # number of samples to show on the plot self.size = 50000 # buffer and offset for the incoming samples self.buffer = bytearray(8 * self.size) self.offset = 0 # create figure figure = Figure() figure.set_facecolor('none') self.axes = figure.add_subplot(111) self.canvas = FigureCanvas(figure) self.plotLayout.addWidget(self.canvas) # create navigation toolbar self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False) # remove subplots action actions = self.toolbar.actions() self.toolbar.removeAction(actions[7]) self.plotLayout.addWidget(self.toolbar) # create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # connect signals from buttons and boxes self.startButton.clicked.connect(self.start) self.freqValue.valueChanged.connect(self.set_freq) self.awidthValue.valueChanged.connect(self.set_awidth) self.deltaValue.valueChanged.connect(self.set_delta) self.rateValue.currentIndexChanged.connect(self.set_rate) # set rate self.rateValue.setCurrentIndex(2) # create timer for the repetitions self.timer = QTimer(self) self.timer.timeout.connect(self.fire) def start(self): if self.idle: self.startButton.setEnabled(False) self.socket.connectToHost(self.addrValue.text(), 1001) else: self.idle = True self.timer.stop() self.socket.close() self.offset = 0 self.startButton.setText('Start') self.startButton.setEnabled(True) def connected(self): self.idle = False self.set_freq(self.freqValue.value()) self.set_rate(self.rateValue.currentIndex()) self.set_awidth(self.awidthValue.value()) self.fire() self.timer.start(self.deltaValue.value()) self.startButton.setText('Stop') self.startButton.setEnabled(True) def read_data(self): size = self.socket.bytesAvailable() if self.offset + size < 8 * self.size: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: self.buffer[self.offset:8 * self.size] = self.socket.read(8 * self.size - self.offset) self.offset = 0 # plot the signal envelope data = np.frombuffer(self.buffer, np.complex64) self.curve.set_ydata(np.abs(data)) self.canvas.draw() def display_error(self, socketError): if socketError == QAbstractSocket.RemoteHostClosedError: pass else: QMessageBox.information(self, 'PulsedNMR', 'Error: %s.' % self.socket.errorString()) self.startButton.setText('Start') self.startButton.setEnabled(True) def set_freq(self, value): if self.idle: return self.socket.write(struct.pack('<I', 0<<28 | int(1.0e6 * value))) def set_rate(self, index): # time axis rate = float(PulsedNMR.rates[index]) time = np.linspace(0.0, (self.size - 1) * 1000.0 / rate, self.size) # reset toolbar self.toolbar.home() self.toolbar._views.clear() self.toolbar._positions.clear() # reset plot self.axes.clear() self.axes.grid() # plot zeros and get store the returned Line2D object self.curve, = self.axes.plot(time, np.zeros(self.size)) x1, x2, y1, y2 = self.axes.axis() # set y axis limits self.axes.axis((x1, x2, -0.1, 0.4)) self.axes.set_xlabel('time, ms') self.canvas.draw() # set repetition time minimum = self.size / rate * 2000.0 if minimum < 100.0: minimum = 100.0 self.deltaValue.setMinimum(minimum) self.deltaValue.setValue(minimum) if self.idle: return self.socket.write(struct.pack('<I', 1<<28 | index)) def set_awidth(self, value): if self.idle: return self.socket.write(struct.pack('<I', 2<<28 | int(1.0e1 * value))) def set_delta(self, value): if self.idle: return self.timer.stop() self.timer.start(value) def fire(self): if self.idle: return self.socket.write(struct.pack('<I', 3<<28))
def run(self): socket = QTcpSocket() if not socket.setSocketDescriptor(self.socketId): self.error.connect(socket.error) return while socket.state() == QAbstractSocket.ConnectedState: nextBlockSize = 0 stream = QDataStream(socket) if socket.waitForReadyRead() and \ socket.bytesAvailable() >= SIZEOF_UINT16: nextBlockSize = stream.readUInt16() else: rec_text = ' 无法正常读取客户端的请求!' rec_text = my_cur_time() + rec_text try: self.lock.lockForWrite() self.recordSignal.sendSignal.emit(rec_text) finally: self.lock.unlock() return if socket.bytesAvailable() < nextBlockSize: if not socket.waitForReadyRead(5000) or \ socket.bytesAvailable() < nextBlockSize: rec_text = ' 无法正常读取客户端的数据!' rec_text = my_cur_time() + rec_text try: self.lock.lockForWrite() self.recordSignal.sendSignal.emit(rec_text) finally: self.lock.unlock() return # MT4交易账号 account_number = stream.readQString() if re.match(r'^[1-9]\d+$', account_number): # 交易指令 trade_instruction = stream.readQString() rec_text = my_cur_time() + ' 已读取到来自 {0} 的交易指令:{1}'.format( account_number, trade_instruction) try: self.lock.lockForWrite() self.recordSignal.sendSignal.emit(rec_text) finally: self.lock.unlock() if account_number in account_dir.keys(): # 将交易信号复制到列表中每个MT4交易账户里 for cur_directory in account_dir.values(): file_path = cur_directory # 将交易指令存到相应账号MT4的Files文件夹里 symbols = ['EURUSD', 'GBPUSD', 'XAUUSD', 'USDJPY'] for symbol in symbols: if trade_instruction.find(symbol) >= 0: trade_symbol = symbol # 检查交易品种的子文件夹是否存在,不存在就新建相应的子文件夹 if os.path.exists(file_path + '\\' + trade_symbol) == False: os.mkdir(file_path + '\\' + trade_symbol) file_path = file_path + '\\' + trade_symbol + '\\' # 将指令存到对应的子文件夹里 file_name = file_path + 'trade_signal.txt' with open(file_name, 'w') as file_object: file_object.write(trade_instruction) reply_text = trade_instruction else: reply_text = 'None' rec_text = my_cur_time( ) + ' 交易账号 {0} 没有获得交易服务器的授权!'.format(account_number) try: self.lock.lockForWrite() self.recordSignal.sendSignal.emit(rec_text) finally: self.lock.unlock() try: self.lock.lockForWrite() rec_text = my_cur_time() + ' 已将交易指令存到相应的MT4的Files文件夹里!' self.recordSignal.sendSignal.emit(rec_text) finally: self.lock.unlock() self.my_sendReply(socket, reply_text) socket.waitForDisconnected() else: rec_text = ' 接收到非正常的数据,可能是网络攻击!' rec_text = my_cur_time() + rec_text try: self.lock.lockForWrite() self.recordSignal.sendSignal.emit(rec_text) finally: self.lock.unlock()
class Averager(QMainWindow, Ui_Averager): def __init__(self): super(Averager, self).__init__() self.setupUi(self) # Set data acquisition variables self.idle = True # state variable self.size = 8193 # number of samples to show on the plot # max size self.buffer = bytearray( 4 * self.size) # buffer and offset for the incoming samples self.offset = 0 self.data = np.frombuffer(self.buffer, np.int32) self.isScaled = True self.isLogScale = False self.isFFT = False self.haveData = False self.showComp = 0 # Real, Imag, Abs, Phase from combo box # Create figure figure = Figure() figure.set_facecolor('none') self.axes = figure.add_subplot(111) self.canvas = FigureCanvas(figure) self.plotLayout.addWidget(self.canvas) # Create navigation toolbar self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False) # Remove subplots action actions = self.toolbar.actions() self.toolbar.removeAction(actions[7]) self.plotLayout.addWidget(self.toolbar) # Create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # Populate Combo boxes self.cbShowComp.clear() self.cbShowComp.addItems(["Real", "Imaginary", "Absolute", "Phase"]) self.cbShowComp.setCurrentIndex(0) self.cbNOS.clear() # Number of Samples for i in range(11): # maximal value set by the FPGA program self.cbNOS.addItems([str(1 << i)]) self.cbNOS.setCurrentIndex(10) self.cbNOA.clear() # Number of Averages for i in range(22): # maximal value could be larger self.cbNOA.addItems([str(1 << i)]) self.cbNOA.setCurrentIndex(0) self.cbTrigger.clear() # Trigger rate for i in range(26): # maximal value set by the FPGA program self.cbTrigger.addItems(["f0/" + str(int(1 << (26 + 1 - i)))]) self.cbTrigger.setCurrentIndex(16) # +1 comes from the fact that counter's lowest bit has f0/2 frequency # Connect UI elements and functions self.btnStart.clicked.connect(self.start) self.chkFFT.stateChanged.connect(self.update_values) self.chkScale.stateChanged.connect(self.update_values) self.chkLogScale.stateChanged.connect(self.update_values) self.cbShowComp.currentIndexChanged.connect(self.update_values) def update_values(self): self.isScaled = self.chkScale.isChecked() self.isLogScale = self.chkLogScale.isChecked() self.isFFT = self.chkFFT.isChecked() self.showComp = self.cbShowComp.currentIndex() self.plot() def start(self): if self.idle: print("connecting ...") self.btnStart.setEnabled(False) self.socket.connectToHost(self.txtIPA.text(), int(self.txtPort.text())) else: self.idle = True self.socket.close() self.offset = 0 self.btnStart.setText('Start') self.btnStart.setEnabled(True) print("Disconnected") def set_config(self): # Number of Samples self.size = int(1 << self.cbNOS.currentIndex()) self.naverages = (1 << int(self.cbNOA.currentIndex())) print("number of samples = " + str(self.size)) print("number of averages = " + str(self.naverages)) print("trigger = " + str(self.cbTrigger.currentIndex())) if self.idle: return self.socket.write( struct.pack('<I', 1 << 28 | self.cbTrigger.currentIndex())) self.socket.write( struct.pack('<I', 2 << 28 | self.cbNOS.currentIndex())) self.socket.write( struct.pack('<I', 3 << 28 | self.cbNOA.currentIndex())) #print( "Configuration sent") def connected(self): print("Connected") self.idle = False self.btnStart.setText('Stop') self.btnStart.setEnabled(True) self.set_config() self.start_measurement() def read_data(self): size = self.socket.bytesAvailable() print("got " + str(size)) if self.offset + size < 4 * self.size: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: #print( "have all the data") self.buffer[self.offset:4 * self.size] = self.socket.read(4 * self.size - self.offset) self.offset = 0 self.haveData = True self.plot() self.idle = True self.socket.close() self.offset = 0 self.btnStart.setText('Start') self.btnStart.setEnabled(True) print("Disconnected") def plot(self): if self.haveData == False: return # reset toolbar self.toolbar.home() ## PyQt4 implementation # self.toolbar._views.clear() # self.toolbar._positions.clear() ## PyQt5 implementation self.toolbar.update() # reset plot self.axes.clear() self.axes.grid() # set data self.time_step = 1. / 125 # us y_data = np.array(self.data[0:self.size], dtype=float) N = self.size # number of complex samples # scale y_data = y_data / self.naverages x_data = np.arange(1, N + 1) xlab = "Index" ylab = "14-bit ADC output" if self.isScaled == True: self.gnd = 0 * -146.6 self.vcc = 1133.7 y_data = 4.96 * (y_data - self.gnd) / (self.vcc - self.gnd) x_data = self.time_step * x_data xlab = 'Time (us)' ylab = 'Voltage' if self.isFFT == True: y_data[-1] = (y_data[0] + y_data[-2]) / 2 y_data = np.fft.fft(y_data) / N x_data = np.fft.fftfreq(y_data.size, self.time_step) x_data = np.fft.fftshift(x_data) y_data = np.fft.fftshift(y_data) xlab = 'Frequency (MHz)' ylab = 'Amplitude' if self.showComp == 0: y_data = y_data.real ylab = "Real " + ylab elif self.showComp == 1: y_data = y_data.imag ylab = "Imag " + ylab elif self.showComp == 2: y_data = np.abs(y_data) ylab = "Abs " + ylab else: y_data = np.angle(y_data) ylab = "Phase " + ylab if self.isLogScale == True: y_data = 20 * np.log10(y_data) ylab = ylab + ' (dBV)' else: ylab = ylab + ' (V)' #print( str(y_data[N/2-1]) + " " + str(y_data[N/2]) + " " + str(y_data[N/2+1])) self.curve = self.axes.plot(x_data, y_data) #x1, x2, y1, y2 = self.axes.axis() # set y axis limits #self.axes.axis((1, self.size, -1500,500)) self.axes.set_xlim([min(x_data), max(x_data)]) self.axes.set_xlabel(xlab) self.axes.set_ylabel(ylab) self.canvas.draw() def display_error(self, socketError): if socketError == QAbstractSocket.RemoteHostClosedError: pass else: QMessageBox.information(self, 'Averager', 'Error: %s.' % self.socket.errorString()) self.btnStart.setText('Start') self.btnStart.setEnabled(True) def start_measurement(self): if self.idle: return self.socket.write(struct.pack('<I', 0 << 28))
class TcpClient(QWidget): def __init__(self): super().__init__() self.isOnline = False self.port = 8888 self.serverIP = QHostAddress('127.0.0.1') self.initUI() def initUI(self): self.ui = ui_tcpClient.Ui_Form() self.ui.setupUi(self) self.ui.sendBtn.setEnabled(False) self.ui.portLineEdit.setText(str(self.port)) self.ui.serverIPLineEdit.setText(self.serverIP.toString()) self.ui.enterBtn.clicked.connect(self.slotEnterOrLeave) self.ui.sendBtn.clicked.connect(self.slotSend) self.ui.sendLineEdit.returnPressed.connect(self.slotSend) self.show() def slotEnterOrLeave(self): if not self.isOnline: if not self.validate(): return self.enterRoom() else: self.leaveRoom() def validate(self): if self.ui.userNameLineEdit.text() == '': QMessageBox().information(self, 'ERROR', 'User Name Error!') return False self.userName = self.ui.userNameLineEdit.text() if not self.serverIP.setAddress( self.ui.serverIPLineEdit.text()): # 判断给定的IP是否能够被正确解析 QMessageBox().information(self, 'ERROR', 'Server IP Error!') return False if not (0 <= int(self.ui.portLineEdit.text()) <= 65535): QMessageBox().information(self, 'ERROR', 'Server Port Error!') return False self.port = int(self.ui.portLineEdit.text()) return True def enterRoom(self): self.tcpSocket = QTcpSocket(self) self.tcpSocket.connectToHost(self.serverIP, self.port) self.tcpSocket.connected.connect(self.slotConnected) self.tcpSocket.readyRead.connect(self.slotDataReceived) self.tcpSocket.disconnected.connect(self.slotDisconnected) self.tcpSocket.error.connect(self.slotErrorOccured) def leaveRoom(self): sendData = '[-] ' + self.userName + ': Leave Chat Room' self.tcpSocket.write(bytes(sendData, encoding='utf-8')) self.tcpSocket.disconnectFromHost() def slotSend(self): if self.ui.sendLineEdit.text() == '': return sendData = self.userName + ': ' + self.ui.sendLineEdit.text() self.tcpSocket.write(bytes(sendData, encoding='utf-8')) self.ui.sendLineEdit.clear() def slotConnected(self): self.ui.sendBtn.setEnabled(True) self.ui.userNameLineEdit.setEnabled(False) self.ui.serverIPLineEdit.setEnabled(False) self.ui.portLineEdit.setEnabled(False) self.ui.enterBtn.setText('Leave Chat Room') self.isOnline = True sendData = '[+] ' + self.userName + ': Enter Chat Room' self.tcpSocket.write(bytes(sendData, encoding='utf-8')) def slotDataReceived(self): recvData = '' while self.tcpSocket.bytesAvailable() > 0: recvData = self.tcpSocket.read(self.tcpSocket.bytesAvailable()) self.ui.contentListWidget.addItem(str(recvData, encoding='utf-8')) self.ui.contentListWidget.scrollToBottom() # 滚动到最后一行 def slotDisconnected(self): self.ui.sendBtn.setEnabled(False) self.ui.userNameLineEdit.setEnabled(True) self.ui.serverIPLineEdit.setEnabled(True) self.ui.portLineEdit.setEnabled(True) self.ui.enterBtn.setText('Enter Chat Room') self.isOnline = False def closeEvent(self, event): if self.isOnline: msg = 'Are you sure to leave the chat room ?' reply = QMessageBox().warning(self, 'Quit', msg, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if reply == QMessageBox.Yes: self.leaveRoom() event.accept() else: event.ignore() else: event.accept() def slotErrorOccured(self, socketError): if socketError == 0: msg = '[*] ConnectionRefusedError: The connection was refused by the peer (or timed out).' self.ui.contentListWidget.addItem(msg) elif socketError == 1: msg = '[*] RemoteHostClosedError: The remote host closed the connection.' self.ui.contentListWidget.addItem(msg)
class VNA(QMainWindow, Ui_VNA): graphs = ['open', 'short', 'load', 'dut', 'smith', 'imp', 'swr', 'gamma', 'rl', 'gain_short', 'gain_open'] def __init__(self): super(VNA, self).__init__() self.setupUi(self) # IP address validator rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$') self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue)) # state variables self.idle = True self.reading = False self.auto = False # sweep parameters self.sweep_start = 10 self.sweep_stop = 60000 self.sweep_size = 6000 # buffer and offset for the incoming samples self.buffer = bytearray(16 * 32768) self.offset = 0 self.data = np.frombuffer(self.buffer, np.complex64) # create measurements self.open = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.short = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.load = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.dut = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.mode = 'open' # create figures self.tabs = {} for i in range(len(self.graphs)): layout = getattr(self, '%sLayout' % self.graphs[i]) self.tabs[i] = FigureTab(layout, self) # configure widgets self.rateValue.addItems(['10000', '5000', '1000', '500', '100', '50', '10', '5', '1']) self.rateValue.lineEdit().setReadOnly(True) self.rateValue.lineEdit().setAlignment(Qt.AlignRight) for i in range(self.rateValue.count()): self.rateValue.setItemData(i, Qt.AlignRight, Qt.TextAlignmentRole) self.set_enabled(False) self.stopSweep.setEnabled(False) # read settings settings = QSettings('vna.ini', QSettings.IniFormat) self.read_cfg_settings(settings) # create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # connect signals from widgets self.connectButton.clicked.connect(self.start) self.writeButton.clicked.connect(self.write_cfg) self.readButton.clicked.connect(self.read_cfg) self.openSweep.clicked.connect(partial(self.sweep, 'open')) self.shortSweep.clicked.connect(partial(self.sweep, 'short')) self.loadSweep.clicked.connect(partial(self.sweep, 'load')) self.singleSweep.clicked.connect(partial(self.sweep, 'dut')) self.autoSweep.clicked.connect(self.sweep_auto) self.stopSweep.clicked.connect(self.cancel) self.csvButton.clicked.connect(self.write_csv) self.s1pButton.clicked.connect(self.write_s1p) self.s2pshortButton.clicked.connect(self.write_s2p_short) self.s2popenButton.clicked.connect(self.write_s2p_open) self.startValue.valueChanged.connect(self.set_start) self.stopValue.valueChanged.connect(self.set_stop) self.sizeValue.valueChanged.connect(self.set_size) self.rateValue.currentIndexChanged.connect(self.set_rate) self.corrValue.valueChanged.connect(self.set_corr) self.phase1Value.valueChanged.connect(self.set_phase1) self.phase2Value.valueChanged.connect(self.set_phase2) self.level1Value.valueChanged.connect(self.set_level1) self.level2Value.valueChanged.connect(self.set_level2) self.tabWidget.currentChanged.connect(self.update_tab) # create timers self.startTimer = QTimer(self) self.startTimer.timeout.connect(self.timeout) self.sweepTimer = QTimer(self) self.sweepTimer.timeout.connect(self.sweep_timeout) def set_enabled(self, enabled): widgets = [self.rateValue, self.level1Value, self.level2Value, self.corrValue, self.phase1Value, self.phase2Value, self.startValue, self.stopValue, self.sizeValue, self.openSweep, self.shortSweep, self.loadSweep, self.singleSweep, self.autoSweep] for entry in widgets: entry.setEnabled(enabled) def start(self): if self.idle: self.connectButton.setEnabled(False) self.socket.connectToHost(self.addrValue.text(), 1001) self.startTimer.start(5000) else: self.stop() def stop(self): self.idle = True self.cancel() self.socket.abort() self.connectButton.setText('Connect') self.connectButton.setEnabled(True) self.set_enabled(False) self.stopSweep.setEnabled(False) def timeout(self): self.display_error('timeout') def connected(self): self.startTimer.stop() self.idle = False self.set_rate(self.rateValue.currentIndex()) self.set_corr(self.corrValue.value()) self.set_phase1(self.phase1Value.value()) self.set_phase2(self.phase2Value.value()) self.set_level1(self.level1Value.value()) self.set_level2(self.level2Value.value()) self.set_gpio(1) self.connectButton.setText('Disconnect') self.connectButton.setEnabled(True) self.set_enabled(True) self.stopSweep.setEnabled(True) def read_data(self): while(self.socket.bytesAvailable() > 0): if not self.reading: self.socket.readAll() return size = self.socket.bytesAvailable() self.progressBar.setValue((self.offset + size) / 16) limit = 16 * self.sweep_size if self.offset + size < limit: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: self.buffer[self.offset:limit] = self.socket.read(limit - self.offset) adc1 = self.data[0::2] adc2 = self.data[1::2] attr = getattr(self, self.mode) start = self.sweep_start stop = self.sweep_stop size = self.sweep_size attr.freq = np.linspace(start, stop, size) attr.data = adc1[0:size].copy() self.update_tab() self.reading = False if not self.auto: self.progressBar.setValue(0) self.set_enabled(True) def display_error(self, socketError): self.startTimer.stop() if socketError == 'timeout': QMessageBox.information(self, 'VNA', 'Error: connection timeout.') else: QMessageBox.information(self, 'VNA', 'Error: %s.' % self.socket.errorString()) self.stop() def set_start(self, value): self.sweep_start = value def set_stop(self, value): self.sweep_stop = value def set_size(self, value): self.sweep_size = value def set_rate(self, value): if self.idle: return rate = [5, 10, 50, 100, 500, 1000, 5000, 10000, 50000][value] self.socket.write(struct.pack('<I', 3<<28 | int(rate))) def set_corr(self, value): if self.idle: return self.socket.write(struct.pack('<I', 4<<28 | int(value))) def set_phase1(self, value): if self.idle: return self.socket.write(struct.pack('<I', 5<<28 | int(value))) def set_phase2(self, value): if self.idle: return self.socket.write(struct.pack('<I', 6<<28 | int(value))) def set_level1(self, value): if self.idle: return data = 0 if value == -90 else int(32766 * np.power(10.0, value / 20.0)) self.socket.write(struct.pack('<I', 7<<28 | int(data))) def set_level2(self, value): if self.idle: return data = 0 if value == -90 else int(32766 * np.power(10.0, value / 20.0)) self.socket.write(struct.pack('<I', 8<<28 | int(data))) def set_gpio(self, value): if self.idle: return self.socket.write(struct.pack('<I', 9<<28 | int(value))) def sweep(self, mode): if self.idle: return self.set_enabled(False) self.mode = mode self.offset = 0 self.reading = True self.socket.write(struct.pack('<I', 0<<28 | int(self.sweep_start * 1000))) self.socket.write(struct.pack('<I', 1<<28 | int(self.sweep_stop * 1000))) self.socket.write(struct.pack('<I', 2<<28 | int(self.sweep_size))) self.socket.write(struct.pack('<I', 10<<28)) self.progressBar.setMinimum(0) self.progressBar.setMaximum(self.sweep_size) self.progressBar.setValue(0) def cancel(self): self.sweepTimer.stop() self.auto = False self.reading = False self.socket.write(struct.pack('<I', 11<<28)) self.progressBar.setValue(0) self.set_enabled(True) def sweep_auto(self): self.auto = True self.sweepTimer.start(100) def sweep_timeout(self): if not self.reading: self.sweep('dut') def update_tab(self): index = self.tabWidget.currentIndex() self.tabs[index].update(self.graphs[index]) def interp(self, freq, meas): real = np.interp(freq, meas.freq, meas.data.real, period = meas.period) imag = np.interp(freq, meas.freq, meas.data.imag, period = meas.period) return real + 1j * imag def gain_short(self, freq): short = self.interp(freq, self.short) dut = self.interp(freq, self.dut) return np.divide(dut, short) def gain_open(self, freq): open = self.interp(freq, self.open) dut = self.interp(freq, self.dut) return np.divide(dut, open) def impedance(self, freq): open = self.interp(freq, self.open) short = self.interp(freq, self.short) load = self.interp(freq, self.load) dut = self.interp(freq, self.dut) z = np.divide(50.0 * (open - load) * (dut - short), (load - short) * (open - dut)) z = np.asarray(z) z.real[z.real < 1.0e-2] = 9.99e-3 return z def gamma(self, freq): z = self.impedance(freq) return np.divide(z - 50.0, z + 50.0) def swr(self, freq): magnitude = np.absolute(self.gamma(freq)) swr = np.divide(1.0 + magnitude, 1.0 - magnitude) return np.clip(swr, 1.0, 99.99) def write_cfg(self): dialog = QFileDialog(self, 'Write configuration settings', '.', '*.ini') dialog.setDefaultSuffix('ini') dialog.selectFile('vna.ini') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() settings = QSettings(name[0], QSettings.IniFormat) self.write_cfg_settings(settings) def read_cfg(self): dialog = QFileDialog(self, 'Read configuration settings', '.', '*.ini') dialog.setDefaultSuffix('ini') dialog.selectFile('vna.ini') dialog.setAcceptMode(QFileDialog.AcceptOpen) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() settings = QSettings(name[0], QSettings.IniFormat) self.read_cfg_settings(settings) window.update_tab() def write_cfg_settings(self, settings): settings.setValue('addr', self.addrValue.text()) settings.setValue('rate', self.rateValue.currentIndex()) settings.setValue('corr', self.corrValue.value()) settings.setValue('phase_1', self.phase1Value.value()) settings.setValue('phase_2', self.phase2Value.value()) settings.setValue('level_1', self.level1Value.value()) settings.setValue('level_2', self.level2Value.value()) settings.setValue('open_start', int(self.open.freq[0])) settings.setValue('open_stop', int(self.open.freq[-1])) settings.setValue('open_size', self.open.freq.size) settings.setValue('short_start', int(self.short.freq[0])) settings.setValue('short_stop', int(self.short.freq[-1])) settings.setValue('short_size', self.short.freq.size) settings.setValue('load_start', int(self.load.freq[0])) settings.setValue('load_stop', int(self.load.freq[-1])) settings.setValue('load_size', self.load.freq.size) settings.setValue('dut_start', int(self.dut.freq[0])) settings.setValue('dut_stop', int(self.dut.freq[-1])) settings.setValue('dut_size', self.dut.freq.size) for i in range(len(FigureTab.cursors)): settings.setValue('cursor_%d' % i, FigureTab.cursors[i]) data = self.open.data for i in range(self.open.freq.size): settings.setValue('open_real_%d' % i, float(data.real[i])) settings.setValue('open_imag_%d' % i, float(data.imag[i])) data = self.short.data for i in range(self.short.freq.size): settings.setValue('short_real_%d' % i, float(data.real[i])) settings.setValue('short_imag_%d' % i, float(data.imag[i])) data = self.load.data for i in range(self.load.freq.size): settings.setValue('load_real_%d' % i, float(data.real[i])) settings.setValue('load_imag_%d' % i, float(data.imag[i])) data = self.dut.data for i in range(self.dut.freq.size): settings.setValue('dut_real_%d' % i, float(data.real[i])) settings.setValue('dut_imag_%d' % i, float(data.imag[i])) def read_cfg_settings(self, settings): self.addrValue.setText(settings.value('addr', '192.168.1.100')) self.rateValue.setCurrentIndex(settings.value('rate', 0, type = int)) self.corrValue.setValue(settings.value('corr', 0, type = int)) self.phase1Value.setValue(settings.value('phase_1', 0, type = int)) self.phase2Value.setValue(settings.value('phase_2', 0, type = int)) self.level1Value.setValue(settings.value('level_1', 0, type = int)) self.level2Value.setValue(settings.value('level_2', -90, type = int)) open_start = settings.value('open_start', 10, type = int) open_stop = settings.value('open_stop', 60000, type = int) open_size = settings.value('open_size', 6000, type = int) short_start = settings.value('short_start', 10, type = int) short_stop = settings.value('short_stop', 60000, type = int) short_size = settings.value('short_size', 6000, type = int) load_start = settings.value('load_start', 10, type = int) load_stop = settings.value('load_stop', 60000, type = int) load_size = settings.value('load_size', 6000, type = int) dut_start = settings.value('dut_start', 10, type = int) dut_stop = settings.value('dut_stop', 60000, type = int) dut_size = settings.value('dut_size', 6000, type = int) self.startValue.setValue(dut_start) self.stopValue.setValue(dut_stop) self.sizeValue.setValue(dut_size) for i in range(len(FigureTab.cursors)): FigureTab.cursors[i] = settings.value('cursor_%d' % i, FigureTab.cursors[i], type = int) self.open.freq = np.linspace(open_start, open_stop, open_size) self.open.data = np.zeros(open_size, np.complex64) for i in range(open_size): real = settings.value('open_real_%d' % i, 0.0, type = float) imag = settings.value('open_imag_%d' % i, 0.0, type = float) self.open.data[i] = real + 1.0j * imag self.short.freq = np.linspace(short_start, short_stop, short_size) self.short.data = np.zeros(short_size, np.complex64) for i in range(short_size): real = settings.value('short_real_%d' % i, 0.0, type = float) imag = settings.value('short_imag_%d' % i, 0.0, type = float) self.short.data[i] = real + 1.0j * imag self.load.freq = np.linspace(load_start, load_stop, load_size) self.load.data = np.zeros(load_size, np.complex64) for i in range(load_size): real = settings.value('load_real_%d' % i, 0.0, type = float) imag = settings.value('load_imag_%d' % i, 0.0, type = float) self.load.data[i] = real + 1.0j * imag self.dut.freq = np.linspace(dut_start, dut_stop, dut_size) self.dut.data = np.zeros(dut_size, np.complex64) for i in range(dut_size): real = settings.value('dut_real_%d' % i, 0.0, type = float) imag = settings.value('dut_imag_%d' % i, 0.0, type = float) self.dut.data[i] = real + 1.0j * imag def write_csv(self): dialog = QFileDialog(self, 'Write csv file', '.', '*.csv') dialog.setDefaultSuffix('csv') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') f = self.dut.freq o = self.interp(f, self.open) s = self.interp(f, self.short) l = self.interp(f, self.load) d = self.dut.data fh.write('frequency;open.real;open.imag;short.real;short.imag;load.real;load.imag;dut.real;dut.imag\n') for i in range(f.size): fh.write('0.0%.8d;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f\n' % (f[i] * 1000, o.real[i], o.imag[i], s.real[i], s.imag[i], l.real[i], l.imag[i], d.real[i], d.imag[i])) fh.close() def write_s1p(self): dialog = QFileDialog(self, 'Write s1p file', '.', '*.s1p') dialog.setDefaultSuffix('s1p') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') freq = self.dut.freq gamma = self.gamma(freq) fh.write('# GHz S MA R 50\n') for i in range(freq.size): fh.write('0.0%.8d %8.6f %7.2f\n' % (freq[i] * 1000, np.absolute(gamma[i]), np.angle(gamma[i], deg = True))) fh.close() def write_s2p(self, gain): dialog = QFileDialog(self, 'Write s2p file', '.', '*.s2p') dialog.setDefaultSuffix('s2p') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') freq = self.dut.freq gamma = self.gamma(freq) fh.write('# GHz S MA R 50\n') for i in range(freq.size): fh.write('0.0%.8d %8.6f %7.2f %8.6f %7.2f 0.000000 0.00 0.000000 0.00\n' % (freq[i] * 1000, np.absolute(gamma[i]), np.angle(gamma[i], deg = True), np.absolute(gain[i]), np.angle(gain[i], deg = True))) fh.close() def write_s2p_short(self): self.write_s2p(self.gain_short(self.dut.freq)) def write_s2p_open(self): self.write_s2p(self.gain_open(self.dut.freq))
class JsonRpcTcpClient(QObject): def __init__(self, request_handler_instance): QObject.__init__(self) self.socket = QTcpSocket(self) self.connectionAttempts = 1 self.socket.readyRead.connect(self.onData) self.socket.error.connect(self.onSocketError) self.request_handler_instance = request_handler_instance self.nextid = 1 self.callbacks_result = {} self.callbacks_error = {} self.buffer = b'' def connect(self, host, port): self.host = host self.port = port self.socket.connectToHost(host, port) @QtCore.pyqtSlot(QAbstractSocket.SocketError) def onSocketError(self, error): if (error == QAbstractSocket.ConnectionRefusedError): self.socket.connectToHost(self.host, self.port) self.connectionAttempts += 1 #self._logger.info("reconnecting to JSONRPC server {}".format(self.connectionAttempts)) else: raise RuntimeError( "Connection error to JSON RPC server: {} ({})".format( self.socket.errorString(), error)) def close(self): self.socket.close() def parseRequest(self, request): try: m = getattr(self.request_handler_instance, request["method"]) if "params" in request and len(request["params"]) > 0: result = m(*request["params"]) else: result = m() # we do not only have a notification, but a request which awaits a response if "id" in request: responseObject = { "id": request["id"], "result": result, "jsonrpc": "2.0" } self.socket.write(json.dumps(responseObject)) except AttributeError: if "id" in request: responseObject = { "id": request["id"], "error": "no such method", "jsonrpc": "2.0" } self.socket.write(json.dumps(responseObject)) def parseResponse(self, response): if "error" in response: self._logger.error("response error {}".format(response)) if "id" in response: if response["id"] in self.callbacks_error: self.callbacks_error[response["id"]](response["error"]) elif "result" in response: if "id" in response: if response["id"] in self.callbacks_result: self.callbacks_result[response["id"]](response["result"]) if "id" in response: self.callbacks_error.pop(response["id"], None) self.callbacks_result.pop(response["id"], None) @QtCore.pyqtSlot() def onData(self): newData = b'' while self.socket.bytesAvailable(): newData += bytes(self.socket.readAll()) # this seems to be a new notification, which invalidates our buffer. This may happen on malformed JSON data if newData.startswith(b"{\"jsonrpc\":\"2.0\""): if len(self.buffer) > 0: self._logger.error( "parse error: discarding old possibly malformed buffer data {}" .format(self.buffer)) self.buffer = newData else: self.buffer += newData self.buffer = self.processBuffer(self.buffer.strip()) #from https://github.com/joncol/jcon-cpp/blob/master/src/jcon/json_rpc_endpoint.cpp#L107 def processBuffer(self, buf): if len(buf) == 0: return b'' if not buf.startswith(b'{'): self._logger.error( "parse error: buffer expected to start {{: {}".format(buf)) return b'' in_string = False brace_nesting_level = 0 for i, c in enumerate(buf): if c == ord('"'): in_string = not in_string if not in_string: if c == ord('{'): brace_nesting_level += 1 if c == ord('}'): brace_nesting_level -= 1 if brace_nesting_level < 0: self._logger.error( "parse error: brace_nesting_level < 0: {}".format( buf)) return b'' if brace_nesting_level == 0: complete_json_buf = buf[:i + 1] remaining_buf = buf[i + 1:] try: request = json.loads(complete_json_buf) except ValueError: self._logger.error( "json.loads failed for {}".format( complete_json_buf)) return b'' print("JsonRpcTcpClient received: {}".format(request)) # is this a request? if "method" in request: self.parseRequest(request) # this is only a response else: self.parseResponse(request) return self.processBuffer(remaining_buf.strip()) return buf def call(self, method, args=[], callback_result=None, callback_error=None): if self.socket.state() != QAbstractSocket.ConnectedState: raise RuntimeError("Not connected to the JSONRPC server.") rpcObject = {"method": method, "params": args, "jsonrpc": "2.0"} if callback_result: rpcObject["id"] = self.nextid self.callbacks_result[self.nextid] = callback_result if callback_error: self.callbacks_error[self.nextid] = callback_error self.nextid += 1 self._logger.debug("sending JSONRPC object {}".format(rpcObject)) self.socket.write(json.dumps(rpcObject).encode("utf-8") + b'\n')
class PulsedNMR(QMainWindow, Ui_PulsedNMR): rates = {0:25.0e3, 1:50.0e3, 2:125.0e3, 3:250.0e3, 4:500.0e3, 5:1250.0e3} def __init__(self): super(PulsedNMR, self).__init__() self.setupUi(self) self.rateValue.addItems(['25', '50', '125', '250', '500', '1250']) # IP address validator rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])|rp-[0-9A-Fa-f]{6}\.local$') self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue)) # state variable self.idle = True # number of samples to show on the plot self.size = 50000 # buffer and offset for the incoming samples self.buffer = bytearray(16 * self.size) self.offset = 0 self.data = np.frombuffer(self.buffer, np.int32) # create figure figure = Figure() figure.set_facecolor('none') self.axes = figure.add_subplot(111) self.canvas = FigureCanvas(figure) self.plotLayout.addWidget(self.canvas) # create navigation toolbar self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False) # remove subplots action actions = self.toolbar.actions() if int(matplotlib.__version__[0]) < 2: self.toolbar.removeAction(actions[7]) else: self.toolbar.removeAction(actions[6]) self.plotLayout.addWidget(self.toolbar) # create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # connect signals from buttons and boxes self.startButton.clicked.connect(self.start) self.freqValue.valueChanged.connect(self.set_freq) self.deltaValue.valueChanged.connect(self.set_delta) self.rateValue.currentIndexChanged.connect(self.set_rate) # set rate self.rateValue.setCurrentIndex(3) # create timer for the repetitions self.startTimer = QTimer(self) self.startTimer.timeout.connect(self.timeout) self.timer = QTimer(self) self.timer.timeout.connect(self.start_sequence) def start(self): if self.idle: self.startButton.setEnabled(False) self.socket.connectToHost(self.addrValue.text(), 1001) self.startTimer.start(5000) else: self.stop() def stop(self): self.idle = True self.timer.stop() self.socket.abort() self.offset = 0 self.startButton.setText('Start') self.startButton.setEnabled(True) def timeout(self): self.display_error('timeout') def connected(self): self.startTimer.stop() self.idle = False self.set_freq(self.freqValue.value()) self.set_rate(self.rateValue.currentIndex()) self.start_sequence() self.timer.start(self.deltaValue.value()) self.startButton.setText('Stop') self.startButton.setEnabled(True) def read_data(self): size = self.socket.bytesAvailable() if self.offset + size < 16 * self.size: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: self.buffer[self.offset:16 * self.size] = self.socket.read(16 * self.size - self.offset) self.offset = 0 # plot the signal envelope self.curve.set_ydata(np.abs(self.data.astype(np.float32).view(np.complex64)[0::2] / (1 << 30))) self.canvas.draw() def display_error(self, socketError): self.startTimer.stop() if socketError == 'timeout': QMessageBox.information(self, 'PulsedNMR', 'Error: connection timeout.') else: QMessageBox.information(self, 'PulsedNMR', 'Error: %s.' % self.socket.errorString()) self.stop() def set_freq(self, value): if self.idle: return self.socket.write(struct.pack('<Q', 0<<60 | int(1.0e6 * value))) self.socket.write(struct.pack('<Q', 1<<60 | int(1.0e6 * value))) def set_rate(self, index): # time axis rate = float(PulsedNMR.rates[index]) time = np.linspace(0.0, (self.size - 1) * 1000.0 / rate, self.size) # reset toolbar self.toolbar.home() self.toolbar.update() # reset plot self.axes.clear() self.axes.grid() # plot zeros and get store the returned Line2D object self.curve, = self.axes.plot(time, np.zeros(self.size)) x1, x2, y1, y2 = self.axes.axis() # set y axis limits self.axes.axis((x1, x2, -0.1, 1.1)) self.axes.set_xlabel('time, ms') self.canvas.draw() if self.idle: return self.socket.write(struct.pack('<Q', 2<<60 | int(125.0e6 / rate / 2))) def set_delta(self, value): if self.idle: return self.timer.stop() self.timer.start(value) def clear_pulses(self): if self.idle: return self.socket.write(struct.pack('<Q', 7<<60)) def add_delay(self, width): if self.idle: return self.socket.write(struct.pack('<Q', 8<<60 | int(width - 4))) def add_pulse(self, level, phase, width): if self.idle: return self.socket.write(struct.pack('<Q', 8<<60 | int(width))) self.socket.write(struct.pack('<Q', 9<<60 | int(phase << 16 | level))) def start_sequence(self): if self.idle: return awidth = 125 * self.awidthValue.value() bwidth = 125 * self.bwidthValue.value() delay = 125 * self.delayValue.value() size = self.size self.clear_pulses() self.add_pulse(32766, 0, awidth) self.add_delay(delay) self.add_pulse(32766, 0, bwidth) self.socket.write(struct.pack('<Q', 10<<60 | int(size)))
class PulsedNMR(QMainWindow, Ui_PulsedNMR): rates = {0: 25.0e3, 1: 50.0e3, 2: 250.0e3, 3: 500.0e3, 4: 2500.0e3} def __init__(self): super(PulsedNMR, self).__init__() self.setupUi(self) self.rateValue.addItems(['25', '50', '250', '500', '2500']) # IP address validator rx = QRegExp( '^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$' ) self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue)) # state variable self.idle = True # number of samples to show on the plot self.size = 50000 # buffer and offset for the incoming samples self.buffer = bytearray(8 * self.size) self.offset = 0 self.data = np.frombuffer(self.buffer, np.complex64) # create figure figure = Figure() figure.set_facecolor('none') self.axes = figure.add_subplot(111) self.canvas = FigureCanvas(figure) self.plotLayout.addWidget(self.canvas) # create navigation toolbar self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False) # remove subplots action actions = self.toolbar.actions() self.toolbar.removeAction(actions[7]) self.plotLayout.addWidget(self.toolbar) # create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # connect signals from buttons and boxes self.startButton.clicked.connect(self.start) self.freqValue.valueChanged.connect(self.set_freq) self.awidthValue.valueChanged.connect(self.set_awidth) self.deltaValue.valueChanged.connect(self.set_delta) self.rateValue.currentIndexChanged.connect(self.set_rate) # set rate self.rateValue.setCurrentIndex(2) # create timer for the repetitions self.timer = QTimer(self) self.timer.timeout.connect(self.fire) def start(self): if self.idle: self.startButton.setEnabled(False) self.socket.connectToHost(self.addrValue.text(), 1001) else: self.idle = True self.timer.stop() self.socket.close() self.offset = 0 self.startButton.setText('Start') self.startButton.setEnabled(True) def connected(self): self.idle = False self.set_freq(self.freqValue.value()) self.set_rate(self.rateValue.currentIndex()) self.set_awidth(self.awidthValue.value()) self.fire() self.timer.start(self.deltaValue.value()) self.startButton.setText('Stop') self.startButton.setEnabled(True) def read_data(self): size = self.socket.bytesAvailable() if self.offset + size < 8 * self.size: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: self.buffer[self.offset:8 * self.size] = self.socket.read(8 * self.size - self.offset) self.offset = 0 # plot the signal envelope self.curve.set_ydata(np.real(self.data)) self.canvas.draw() def display_error(self, socketError): if socketError == QAbstractSocket.RemoteHostClosedError: pass else: QMessageBox.information(self, 'PulsedNMR', 'Error: %s.' % self.socket.errorString()) self.startButton.setText('Start') self.startButton.setEnabled(True) def set_freq(self, value): if self.idle: return self.socket.write(struct.pack('<I', 0 << 28 | int(1.0e6 * value))) def set_rate(self, index): # time axis rate = float(PulsedNMR.rates[index]) time = np.linspace(0.0, (self.size - 1) * 1000.0 / rate, self.size) # reset toolbar self.toolbar.home() self.toolbar._views.clear() self.toolbar._positions.clear() # reset plot self.axes.clear() self.axes.grid() # plot zeros and get store the returned Line2D object self.curve, = self.axes.plot(time, np.zeros(self.size)) x1, x2, y1, y2 = self.axes.axis() # set y axis limits self.axes.axis((x1, x2, -0.1, 0.4)) self.axes.set_xlabel('time, ms') self.canvas.draw() # set repetition time minimum = self.size / rate * 2000.0 if minimum < 100.0: minimum = 100.0 self.deltaValue.setMinimum(minimum) self.deltaValue.setValue(minimum) if self.idle: return self.socket.write(struct.pack('<I', 1 << 28 | index)) def set_awidth(self, value): if self.idle: return self.socket.write(struct.pack('<I', 2 << 28 | int(1.0e1 * value))) def set_delta(self, value): if self.idle: return self.timer.stop() self.timer.start(value) def fire(self): if self.idle: return self.socket.write(struct.pack('<I', 3 << 28))
class Thread(QThread): lock = QReadWriteLock() sinOut1 = pyqtSignal(str) #信号量变量 sinOut2 = pyqtSignal(str) # 信号量变量 sinOut3 = pyqtSignal(str) #socket = QTcpSocket() def __init__(self, socketId, parent): super(Thread, self).__init__(parent) self.socketId = socketId def run(self): self.socket = QTcpSocket() self.myclientid1 = 0 if not self.socket.setSocketDescriptor(self.socketId): self.error.connect(self.socket.error) return self.sinOut1.emit( str(self.socketId) + "#" + QDateTime.currentDateTime().toString("yyyy-MM-dd HH:mm:ss") ) #发送信号量 //建立连接 while self.socket.state() == QAbstractSocket.ConnectedState: if (self.socket.waitForReadyRead(1000 * 60 * 10) and self.socket.bytesAvailable() > 0): #waitForReadyRead(1000*60*10)说明,单位为毫秒,时间内等待接收数据,超时为假 mygetdata = self.socket.readAll() mygetdata = bytes(mygetdata) #print(mygetdata) self.sinOut2.emit("get data:" + str(mygetdata)) #client发送来的数据 #分析客户端数据中的ID值 myclientid = self.myanalyseframe(mygetdata) if myclientid != 0 and myclientid != self.myclientid1: self.myclientid1 = myclientid # 利用client数据,标识处TCP连接的对象ID值,指令中的值 self.sinOut1.emit( str(self.socketId) + "#" + QDateTime.currentDateTime().toString( "yyyy-MM-dd HH:mm:ss") + "#" + str(myclientid)) else: self.senddata(self.socket, 'TCP time out') self.sinOut3.emit(str(self.socketId)) #超时,线程结束,删除前台listw中的条目 return #超时,线程结束 def sendStr(self, socket, msg): mysentdata = msg.encode('utf-8') socket.write(mysentdata) def senddata(self, socket, data): if isinstance(data, str) == True: mysentdata = data.encode('utf-8') elif isinstance(data, list) == True: mysentdata = bytes(data) elif isinstance(data, int) == True or isinstance(data, float) == True: mysentdata = str(data) mysentdata = mysentdata.encode('utf-8') else: mysentdata = data #print(mysentdata) socket.write(mysentdata) self.sinOut2.emit("send data:" + str(mysentdata)) def getUIsenddata(self, data): pass mystr1 = data.split(',') mystr1 = [int(x) // 10 * 16 + int(x) % 10 for x in mystr1] mystr1 = bytes(mystr1) self.senddata(self.socket, mystr1) ########################################## ##############业务逻辑部分############# def myanalyseframe(self, mydata): pass if isinstance(mydata, str) == True: mygetdata = mydata.encode('utf-8') elif isinstance(mydata, list) == True: mygetdata = bytes(mydata) elif isinstance(mydata, int) == True or isinstance(mydata, float) == True: mygetdata = str(mydata) mygetdata = mygetdata.encode('utf-8') else: mygetdata = mydata mydata1 = mygetdata if len(mydata1) != 6: pass return 0 if mydata1[0] == 0x10 and mydata1[5] == 0x16: myclientid = int(mydata1[2]) + int(mydata1[3]) * 256 pass return myclientid else: pass return 0
class sendMessage(QObject): doSomeThing = pyqtSignal(str) # 收到一条命令去执行 def __init__(self, parent=None): # 初始化发送对象,首先要先建立连接 super(sendMessage, self).__init__(parent) self.socket = QTcpSocket() self.nextBlockSize = 0 self.socket.connectToHost(IP, PORT) self.deviceInfo = deviceInfo(DEVICE_FIX_ID, REGION_PROVINCE, REGION_CITY, REGION_AREA) # 保存盒子信息,可从某个文件读取 self.socket.connected.connect(self.initConnected) # 初始化连接,第一次连上就发送信息 self.socket.waitForConnected() # 等待设备连接完成 time.sleep(0.1) self.socket.readyRead.connect(self.readResponse) self.socket.disconnected.connect(self.serverHasStopped) self.socket.error.connect(self.serverHasError) self.doSomeThing.connect(self.doWhat) # 收到某条命令要执行的函数 def doWhat(self, order): # 收到dosome命令要执行的函数 if order: if ',' in order: order, model_type = order.split(",") else: model_type = None order_instance = generateOrder(order) t = Thread(target=order_instance.run, args=(self.deviceInfo, IP, 8870, model_type)) t.start() def fileToBytes(self, fileName): # 将文件转换成二进制 file = QFile(fileName) print(file.size()) count = 0 with open(fileName, 'rb') as f: while 1: filedata = f.read(1024) if not filedata: break count = count + filedata.__len__() print(count) @startSendMessage def initConnected( self, stream): # 每次连接上后 发送盒子的设备信息 fixID(固定id) region(所在地区) stream.writeQString('deviceInfo') # 设定信息类型 state deviceInfoToByte = pickle.dumps( deviceInfoJson ) # 将设备信息序列化成二进制发送 s = pickle.dumps(sendMessage1.deviceInfo) stream.writeBytes(deviceInfoToByte) ''' 接下来还有几点 1、盒子连接建立,发送设备信息。接收端接收一次。 2、规定好发送文件的格式 3、设计数据库 4、与网页交互 ''' @startSendMessage def sendFileBytes(self, stream, filePath, fileBytes): # stream 由装饰器传值 状态 文件名 文件字节 file = QFile(filePath) print(filePath) stream.writeQString('sendFile') # 发送文件 状态 stream.writeQString(file.fileName()) # 发送文件的名字 print(file.size()) stream.writeQString(str(file.size())) # 发送文件的大小 stream.writeBytes(fileBytes) def sendFile(self, filePath): with open(filePath, 'rb') as f: count = 0 while 1: # 循环传输 filedata = f.read(204800) print(filedata.__sizeof__()) if not filedata: break self.sendFileBytes(filePath, filedata) count = count + filedata.__sizeof__() print(count) @startSendMessage def sendImage(self, stream, imagePath, kind): # 传递图片,与图片类型 状态 图片类型 图片 stream.writeQString('sendImage') stream.writeQString(kind) stream.writeBytes(self.fileToBytes(imagePath)) @startSendMessage def sendResult( self, stream, kind, result, startTime, usedTime): # ,发送成功的状态,发送来 success 日期 信号类型 识别结果 识别开始时间 识别时间 stream.writeQString('successResult') # 发送成功状态 dateNow = time.strftime("%Y-%m-%d", time.localtime()) resultObject = resultInfo(dateNow, kind, result, startTime, usedTime) # 结果对象 (日期,类型,结果,开始时间,识别用时) resultBytes = pickle.dumps(resultObject) stream.writeBytes(resultBytes) def readResponse(self): # 收命令,要做的事情, stream = QDataStream(self.socket) print('--------------------') print('服务器响应') stream.setVersion(QDataStream.Qt_5_7) while True: self.nextBlockSize = 0 if self.nextBlockSize == 0: if self.socket.bytesAvailable() < SIZEOF_UINT16: print('没有内容了') break self.nextBlockSize = stream.readUInt16() else: print('错误') # 客户端主动断开时,去掉字典中的对应,在这里做一部分操作。 # 客户端主动断开的时候,要将其从self.myParent.sockeIdToSocketDict self.myParent.fixIdToSocketIdDict 中删掉 break if self.socket.bytesAvailable() < self.nextBlockSize: print("错误2") if (not self.socket.waitForReadyRead(60000) or self.socket.bytesAvailable() < self.nextBlockSize): break state = stream.readQString() # 读命令 sendModel print('state==' + state) if state == 'SENDFILE': filename = stream.readQString() # 读文件名 fileSize = stream.readInt() # 读文件大小 with open('../TEST/' + filename, 'ab') as f: while self.nextBlockSize > 0: fileBytes = stream.readBytes() # 读文件部分字节 f.write(fileBytes) print(fileBytes.__len__()) self.nextBlockSize = stream.readUInt64() print('self.nextBlockSize:' + str(self.nextBlockSize)) state = stream.readQString() filename = stream.readQString() # 读文件名 fileSize = stream.readInt() # 读文件大小 print('filename:' + filename) print('fileSize:' + str(fileSize)) elif state == 'test': print(stream.readQString()) elif state == 'ORDER': # 收到一条命令 要执行的命令 order = stream.readQString() # 读是什么命令 if order: # shou dao doThing self.doSomeThing.emit(order) def serverHasStopped(self): print('连接断开') self.socket.close() self.socket = QTcpSocket() print(self.socket.state()) # while self.socket.state() == 0: # print("重新连接") # time.sleep(5) # self.socket.connectToHost(IP, PORT) # self.socket.waitForConnected() # self.socket.close() def serverHasError(self, error): self.socket.close()
class VNA(QMainWindow, Ui_VNA): graphs = ['open', 'short', 'load', 'dut', 'smith', 'imp', 'swr', 'gamma', 'rl', 'gain_short', 'gain_open'] def __init__(self): super(VNA, self).__init__() self.setupUi(self) # IP address validator rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$') self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue)) # state variables self.idle = True self.reading = False self.auto = False # sweep parameters self.sweep_start = 10 self.sweep_stop = 60000 self.sweep_size = 6000 # buffer and offset for the incoming samples self.buffer = bytearray(16 * 32768) self.offset = 0 self.data = np.frombuffer(self.buffer, np.complex64) # create measurements self.open = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.short = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.load = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.dut = Measurement(self.sweep_start, self.sweep_stop, self.sweep_size) self.mode = 'open' # create figures self.tabs = {} for i in range(len(self.graphs)): layout = getattr(self, '%sLayout' % self.graphs[i]) self.tabs[i] = FigureTab(layout, self.open, self.short, self.load, self.dut) # configure widgets self.rateValue.addItems(['10000', '5000', '1000', '500', '100', '50', '10', '5', '1']) self.rateValue.lineEdit().setReadOnly(True) self.rateValue.lineEdit().setAlignment(Qt.AlignRight) for i in range(self.rateValue.count()): self.rateValue.setItemData(i, Qt.AlignRight, Qt.TextAlignmentRole) self.set_enabled(False) # read settings settings = QSettings('vna.ini', QSettings.IniFormat) self.read_cfg_settings(settings) # create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # connect signals from widgets self.connectButton.clicked.connect(self.start) self.writeButton.clicked.connect(self.write_cfg) self.readButton.clicked.connect(self.read_cfg) self.openSweep.clicked.connect(partial(self.sweep, 'open')) self.shortSweep.clicked.connect(partial(self.sweep, 'short')) self.loadSweep.clicked.connect(partial(self.sweep, 'load')) self.singleSweep.clicked.connect(partial(self.sweep, 'dut')) self.autoSweep.clicked.connect(self.sweep_auto) self.stopSweep.clicked.connect(self.cancel) self.csvButton.clicked.connect(self.write_csv) self.s1pButton.clicked.connect(self.write_s1p) self.s2pshortButton.clicked.connect(self.write_s2p_short) self.s2popenButton.clicked.connect(self.write_s2p_open) self.startValue.valueChanged.connect(self.set_start) self.stopValue.valueChanged.connect(self.set_stop) self.sizeValue.valueChanged.connect(self.set_size) self.rateValue.currentIndexChanged.connect(self.set_rate) self.corrValue.valueChanged.connect(self.set_corr) self.levelValue.valueChanged.connect(self.set_level) self.tabWidget.currentChanged.connect(self.update_tab) # create timers self.startTimer = QTimer(self) self.startTimer.timeout.connect(self.timeout) self.sweepTimer = QTimer(self) self.sweepTimer.timeout.connect(self.sweep_timeout) def set_enabled(self, enabled): widgets = [self.corrValue, self.rateValue, self.levelValue, self.sizeValue, self.stopValue, self.startValue, self.openSweep, self.shortSweep, self.loadSweep, self.singleSweep, self.autoSweep] for entry in widgets: entry.setEnabled(enabled) def start(self): if self.idle: self.connectButton.setEnabled(False) self.socket.connectToHost(self.addrValue.text(), 1001) self.startTimer.start(5000) else: self.stop() def stop(self): self.idle = True self.cancel() self.socket.abort() self.connectButton.setText('Connect') self.connectButton.setEnabled(True) self.set_enabled(False) def timeout(self): self.display_error('timeout') def connected(self): self.startTimer.stop() self.idle = False self.set_rate(self.rateValue.currentIndex()) self.set_corr(self.corrValue.value()) self.set_level(self.levelValue.value()) self.set_gpio(1) self.connectButton.setText('Disconnect') self.connectButton.setEnabled(True) self.set_enabled(True) def read_data(self): while(self.socket.bytesAvailable() > 0): if not self.reading: self.socket.readAll() return size = self.socket.bytesAvailable() self.progressBar.setValue((self.offset + size) / 16) limit = 16 * self.sweep_size if self.offset + size < limit: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: self.buffer[self.offset:limit] = self.socket.read(limit - self.offset) adc1 = self.data[0::2] adc2 = self.data[1::2] attr = getattr(self, self.mode) start = self.sweep_start stop = self.sweep_stop size = self.sweep_size attr.freq = np.linspace(start, stop, size) attr.data = adc1[0:size].copy() self.update_tab() self.reading = False if not self.auto: self.progressBar.setValue(0) self.set_enabled(True) def display_error(self, socketError): self.startTimer.stop() if socketError == 'timeout': QMessageBox.information(self, 'VNA', 'Error: connection timeout.') else: QMessageBox.information(self, 'VNA', 'Error: %s.' % self.socket.errorString()) self.stop() def set_start(self, value): self.sweep_start = value def set_stop(self, value): self.sweep_stop = value def set_size(self, value): self.sweep_size = value def set_rate(self, value): if self.idle: return rate = [5, 10, 50, 100, 500, 1000, 5000, 10000, 50000][value] self.socket.write(struct.pack('<I', 3<<28 | int(rate))) def set_corr(self, value): if self.idle: return self.socket.write(struct.pack('<I', 4<<28 | int(value))) def set_level(self, value): if self.idle: return self.socket.write(struct.pack('<I', 5<<28 | int(32766 * np.power(10.0, value / 20.0)))) self.socket.write(struct.pack('<I', 6<<28 | int(0))) def set_gpio(self, value): if self.idle: return self.socket.write(struct.pack('<I', 7<<28 | int(value))) def sweep(self, mode): if self.idle: return self.set_enabled(False) self.mode = mode self.offset = 0 self.reading = True self.socket.write(struct.pack('<I', 0<<28 | int(self.sweep_start * 1000))) self.socket.write(struct.pack('<I', 1<<28 | int(self.sweep_stop * 1000))) self.socket.write(struct.pack('<I', 2<<28 | int(self.sweep_size))) self.socket.write(struct.pack('<I', 8<<28)) self.progressBar.setMinimum(0) self.progressBar.setMaximum(self.sweep_size) self.progressBar.setValue(0) def cancel(self): self.sweepTimer.stop() self.auto = False self.reading = False self.socket.write(struct.pack('<I', 9<<28)) self.progressBar.setValue(0) self.set_enabled(True) def sweep_auto(self): self.auto = True self.sweepTimer.start(100) def sweep_timeout(self): if not self.reading: self.sweep('dut') def update_tab(self): index = self.tabWidget.currentIndex() self.tabs[index].update(self.graphs[index]) def write_cfg(self): dialog = QFileDialog(self, 'Write configuration settings', '.', '*.ini') dialog.setDefaultSuffix('ini') dialog.selectFile('vna.ini') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() settings = QSettings(name[0], QSettings.IniFormat) self.write_cfg_settings(settings) def read_cfg(self): dialog = QFileDialog(self, 'Read configuration settings', '.', '*.ini') dialog.setDefaultSuffix('ini') dialog.selectFile('vna.ini') dialog.setAcceptMode(QFileDialog.AcceptOpen) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() settings = QSettings(name[0], QSettings.IniFormat) self.read_cfg_settings(settings) window.update_tab() def write_cfg_settings(self, settings): settings.setValue('addr', self.addrValue.text()) settings.setValue('rate', self.rateValue.currentIndex()) settings.setValue('corr', self.corrValue.value()) settings.setValue('level', self.levelValue.value()) settings.setValue('open_start', int(self.open.freq[0])) settings.setValue('open_stop', int(self.open.freq[-1])) settings.setValue('open_size', self.open.freq.size) settings.setValue('short_start', int(self.short.freq[0])) settings.setValue('short_stop', int(self.short.freq[-1])) settings.setValue('short_size', self.short.freq.size) settings.setValue('load_start', int(self.load.freq[0])) settings.setValue('load_stop', int(self.load.freq[-1])) settings.setValue('load_size', self.load.freq.size) settings.setValue('dut_start', int(self.dut.freq[0])) settings.setValue('dut_stop', int(self.dut.freq[-1])) settings.setValue('dut_size', self.dut.freq.size) for i in range(len(FigureTab.cursors)): settings.setValue('cursor_%d' % i, FigureTab.cursors[i]) data = self.open.data for i in range(self.open.freq.size): settings.setValue('open_real_%d' % i, float(data.real[i])) settings.setValue('open_imag_%d' % i, float(data.imag[i])) data = self.short.data for i in range(self.short.freq.size): settings.setValue('short_real_%d' % i, float(data.real[i])) settings.setValue('short_imag_%d' % i, float(data.imag[i])) data = self.load.data for i in range(self.load.freq.size): settings.setValue('load_real_%d' % i, float(data.real[i])) settings.setValue('load_imag_%d' % i, float(data.imag[i])) data = self.dut.data for i in range(self.dut.freq.size): settings.setValue('dut_real_%d' % i, float(data.real[i])) settings.setValue('dut_imag_%d' % i, float(data.imag[i])) def read_cfg_settings(self, settings): self.addrValue.setText(settings.value('addr', '192.168.1.100')) self.rateValue.setCurrentIndex(settings.value('rate', 0, type = int)) self.corrValue.setValue(settings.value('corr', 0, type = int)) self.levelValue.setValue(settings.value('level', 0, type = int)) open_start = settings.value('open_start', 10, type = int) open_stop = settings.value('open_stop', 60000, type = int) open_size = settings.value('open_size', 6000, type = int) short_start = settings.value('short_start', 10, type = int) short_stop = settings.value('short_stop', 60000, type = int) short_size = settings.value('short_size', 6000, type = int) load_start = settings.value('load_start', 10, type = int) load_stop = settings.value('load_stop', 60000, type = int) load_size = settings.value('load_size', 6000, type = int) dut_start = settings.value('dut_start', 10, type = int) dut_stop = settings.value('dut_stop', 60000, type = int) dut_size = settings.value('dut_size', 6000, type = int) self.startValue.setValue(dut_start) self.stopValue.setValue(dut_stop) self.sizeValue.setValue(dut_size) for i in range(len(FigureTab.cursors)): FigureTab.cursors[i] = settings.value('cursor_%d' % i, FigureTab.cursors[i], type = int) self.open.freq = np.linspace(open_start, open_stop, open_size) self.open.data = np.zeros(open_size, np.complex64) for i in range(open_size): real = settings.value('open_real_%d' % i, 0.0, type = float) imag = settings.value('open_imag_%d' % i, 0.0, type = float) self.open.data[i] = real + 1.0j * imag self.short.freq = np.linspace(short_start, short_stop, short_size) self.short.data = np.zeros(short_size, np.complex64) for i in range(short_size): real = settings.value('short_real_%d' % i, 0.0, type = float) imag = settings.value('short_imag_%d' % i, 0.0, type = float) self.short.data[i] = real + 1.0j * imag self.load.freq = np.linspace(load_start, load_stop, load_size) self.load.data = np.zeros(load_size, np.complex64) for i in range(load_size): real = settings.value('load_real_%d' % i, 0.0, type = float) imag = settings.value('load_imag_%d' % i, 0.0, type = float) self.load.data[i] = real + 1.0j * imag self.dut.freq = np.linspace(dut_start, dut_stop, dut_size) self.dut.data = np.zeros(dut_size, np.complex64) for i in range(dut_size): real = settings.value('dut_real_%d' % i, 0.0, type = float) imag = settings.value('dut_imag_%d' % i, 0.0, type = float) self.dut.data[i] = real + 1.0j * imag def write_csv(self): dialog = QFileDialog(self, 'Write csv file', '.', '*.csv') dialog.setDefaultSuffix('csv') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') f = self.dut.freq o = np.interp(f, self.open.freq, self.open.data, period = self.open.period) s = np.interp(f, self.short.freq, self.short.data, period = self.short.period) l = np.interp(f, self.load.freq, self.load.data, period = self.load.period) d = self.dut.data fh.write('frequency;open.real;open.imag;short.real;short.imag;load.real;load.imag;dut.real;dut.imag\n') for i in range(f.size): fh.write('0.0%.8d;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f\n' % (f[i] * 1000, o.real[i], o.imag[i], s.real[i], s.imag[i], l.real[i], l.imag[i], d.real[i], d.imag[i])) fh.close() def write_s1p(self): dialog = QFileDialog(self, 'Write s1p file', '.', '*.s1p') dialog.setDefaultSuffix('s1p') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') freq = self.dut.freq gamma = self.gamma(freq) fh.write('# GHz S MA R 50\n') for i in range(freq.size): fh.write('0.0%.8d %8.6f %7.2f\n' % (freq[i] * 1000, np.absolute(gamma[i]), np.angle(gamma[i], deg = True))) fh.close() def write_s2p(self, gain): dialog = QFileDialog(self, 'Write s2p file', '.', '*.s2p') dialog.setDefaultSuffix('s2p') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') freq = self.dut.freq gamma = self.gamma(freq) fh.write('# GHz S MA R 50\n') for i in range(freq.size): fh.write('0.0%.8d %8.6f %7.2f %8.6f %7.2f 0.000000 0.00 0.000000 0.00\n' % (freq[i] * 1000, np.absolute(gamma[i]), np.angle(gamma[i], deg = True), np.absolute(gain[i]), np.angle(gain[i], deg = True))) fh.close() def write_s2p_short(self): self.write_s2p(self.gain_short(self.dut.freq)) def write_s2p_open(self): self.write_s2p(self.gain_open(self.dut.freq))
class VNA(QMainWindow, Ui_VNA): max_size = 16384 def __init__(self): super(VNA, self).__init__() self.setupUi(self) # IP address validator rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$') self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue)) # state variables self.idle = True self.reading = False # sweep parameters self.sweep_start = 100 self.sweep_stop = 60000 self.sweep_size = 600 self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True) self.xaxis *= 1000 # buffer and offset for the incoming samples self.buffer = bytearray(24 * VNA.max_size) self.offset = 0 self.data = np.frombuffer(self.buffer, np.complex64) self.adc1 = np.zeros(VNA.max_size, np.complex64) self.adc2 = np.zeros(VNA.max_size, np.complex64) self.dac1 = np.zeros(VNA.max_size, np.complex64) self.open = np.zeros(VNA.max_size, np.complex64) self.short = np.zeros(VNA.max_size, np.complex64) self.load = np.zeros(VNA.max_size, np.complex64) self.dut = np.zeros(VNA.max_size, np.complex64) self.mode = 'dut' # create figure self.figure = Figure() self.figure.set_facecolor('none') self.canvas = FigureCanvas(self.figure) self.plotLayout.addWidget(self.canvas) # create navigation toolbar self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False) # initialize cursor self.cursor = None # remove subplots action actions = self.toolbar.actions() self.toolbar.removeAction(actions[7]) self.plotLayout.addWidget(self.toolbar) # create TCP socket self.socket = QTcpSocket(self) self.socket.connected.connect(self.connected) self.socket.readyRead.connect(self.read_data) self.socket.error.connect(self.display_error) # connect signals from buttons and boxes self.sweepFrame.setEnabled(False) self.dutSweep.setEnabled(False) self.connectButton.clicked.connect(self.start) self.writeButton.clicked.connect(self.write_cfg) self.readButton.clicked.connect(self.read_cfg) self.openSweep.clicked.connect(self.sweep_open) self.shortSweep.clicked.connect(self.sweep_short) self.loadSweep.clicked.connect(self.sweep_load) self.dutSweep.clicked.connect(self.sweep_dut) self.csvButton.clicked.connect(self.write_csv) self.s1pButton.clicked.connect(self.write_s1p) self.s2pButton.clicked.connect(self.write_s2p) self.startValue.valueChanged.connect(self.set_start) self.stopValue.valueChanged.connect(self.set_stop) self.sizeValue.valueChanged.connect(self.set_size) self.rateValue.addItems(['500', '100', '50', '10', '5', '1']) self.rateValue.lineEdit().setReadOnly(True) self.rateValue.lineEdit().setAlignment(Qt.AlignRight) for i in range(0, self.rateValue.count()): self.rateValue.setItemData(i, Qt.AlignRight, Qt.TextAlignmentRole) self.rateValue.currentIndexChanged.connect(self.set_rate) self.corrValue.valueChanged.connect(self.set_corr) self.levelValue.valueChanged.connect(self.set_level) self.openPlot.clicked.connect(self.plot_open) self.shortPlot.clicked.connect(self.plot_short) self.loadPlot.clicked.connect(self.plot_load) self.dutPlot.clicked.connect(self.plot_dut) self.smithPlot.clicked.connect(self.plot_smith) self.impPlot.clicked.connect(self.plot_imp) self.rcPlot.clicked.connect(self.plot_rc) self.swrPlot.clicked.connect(self.plot_swr) self.rlPlot.clicked.connect(self.plot_rl) self.gainPlot.clicked.connect(self.plot_gain) # create timer self.startTimer = QTimer(self) self.startTimer.timeout.connect(self.timeout) def start(self): if self.idle: self.connectButton.setEnabled(False) self.socket.connectToHost(self.addrValue.text(), 1001) self.startTimer.start(5000) else: self.stop() def stop(self): self.idle = True self.socket.abort() self.connectButton.setText('Connect') self.connectButton.setEnabled(True) self.sweepFrame.setEnabled(False) self.selectFrame.setEnabled(True) self.dutSweep.setEnabled(False) def timeout(self): self.display_error('timeout') def connected(self): self.startTimer.stop() self.idle = False self.set_start(self.startValue.value()) self.set_stop(self.stopValue.value()) self.set_size(self.sizeValue.value()) self.set_rate(self.rateValue.currentIndex()) self.set_corr(self.corrValue.value()) self.set_level(self.levelValue.value()) self.connectButton.setText('Disconnect') self.connectButton.setEnabled(True) self.sweepFrame.setEnabled(True) self.dutSweep.setEnabled(True) def read_data(self): if not self.reading: self.socket.readAll() return size = self.socket.bytesAvailable() self.progress.setValue((self.offset + size) / 24) limit = 24 * (self.sweep_size + 1) if self.offset + size < limit: self.buffer[self.offset:self.offset + size] = self.socket.read(size) self.offset += size else: self.buffer[self.offset:limit] = self.socket.read(limit - self.offset) self.adc1 = self.data[0::3] self.adc2 = self.data[1::3] self.dac1 = self.data[2::3] getattr(self, self.mode)[0:self.sweep_size] = self.adc1[1:self.sweep_size + 1] / self.dac1[1:self.sweep_size + 1] getattr(self, 'plot_%s' % self.mode)() self.reading = False self.sweepFrame.setEnabled(True) self.selectFrame.setEnabled(True) def display_error(self, socketError): self.startTimer.stop() if socketError == 'timeout': QMessageBox.information(self, 'VNA', 'Error: connection timeout.') else: QMessageBox.information(self, 'VNA', 'Error: %s.' % self.socket.errorString()) self.stop() def set_start(self, value): self.sweep_start = value self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True) self.xaxis *= 1000 if self.idle: return self.socket.write(struct.pack('<I', 0<<28 | int(value * 1000))) def set_stop(self, value): self.sweep_stop = value self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True) self.xaxis *= 1000 if self.idle: return self.socket.write(struct.pack('<I', 1<<28 | int(value * 1000))) def set_size(self, value): self.sweep_size = value self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True) self.xaxis *= 1000 if self.idle: return self.socket.write(struct.pack('<I', 2<<28 | int(value))) def set_rate(self, value): if self.idle: return rate = [1, 5, 10, 50, 100, 500][value] self.socket.write(struct.pack('<I', 3<<28 | int(rate))) def set_corr(self, value): if self.idle: return self.socket.write(struct.pack('<I', 4<<28 | int(value))) def set_level(self, value): if self.idle: return self.socket.write(struct.pack('<I', 5<<28 | int(32767 * np.power(10.0, value / 20.0)))) def sweep(self): if self.idle: return self.sweepFrame.setEnabled(False) self.selectFrame.setEnabled(False) self.socket.write(struct.pack('<I', 6<<28)) self.offset = 0 self.reading = True self.progress = QProgressDialog('Sweep status', 'Cancel', 0, self.sweep_size + 1) self.progress.setModal(True) self.progress.setMinimumDuration(1000) self.progress.canceled.connect(self.cancel) def cancel(self): self.offset = 0 self.reading = False self.socket.write(struct.pack('<I', 7<<28)) self.sweepFrame.setEnabled(True) self.selectFrame.setEnabled(True) def sweep_open(self): self.mode = 'open' self.sweep() def sweep_short(self): self.mode = 'short' self.sweep() def sweep_load(self): self.mode = 'load' self.sweep() def sweep_dut(self): self.mode = 'dut' self.sweep() def gain(self): size = self.sweep_size return self.dut[0:size]/self.short[0:size] def impedance(self): size = self.sweep_size return 50.0 * (self.open[0:size] - self.load[0:size]) * (self.dut[0:size] - self.short[0:size]) / ((self.load[0:size] - self.short[0:size]) * (self.open[0:size] - self.dut[0:size])) def gamma(self): z = self.impedance() return (z - 50.0)/(z + 50.0) def plot_gain(self): if self.cursor is not None: self.cursor.hide().disable() matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(left = 0.12, bottom = 0.12, right = 0.88, top = 0.98) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.tick_params('y', color = 'blue', labelcolor = 'blue') axes1.yaxis.label.set_color('blue') gain = self.gain() axes1.plot(self.xaxis, 20.0 * np.log10(np.absolute(gain)), color = 'blue', label = 'Gain') axes2 = axes1.twinx() axes2.spines['left'].set_color('blue') axes2.spines['right'].set_color('red') axes1.set_xlabel('Hz') axes1.set_ylabel('Gain, dB') axes2.set_ylabel('Phase angle') axes2.tick_params('y', color = 'red', labelcolor = 'red') axes2.yaxis.label.set_color('red') axes2.plot(self.xaxis, np.angle(gain, deg = True), color = 'red', label = 'Phase angle') self.cursor = datacursor(axes = self.figure.get_axes(), formatter = LabelFormatter(), display = 'multiple') self.canvas.draw() def plot_magphase(self, data): if self.cursor is not None: self.cursor.hide().disable() matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(left = 0.12, bottom = 0.12, right = 0.88, top = 0.98) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.tick_params('y', color = 'blue', labelcolor = 'blue') axes1.yaxis.label.set_color('blue') axes1.plot(self.xaxis, np.absolute(data), color = 'blue', label = 'Magnitude') axes2 = axes1.twinx() axes2.spines['left'].set_color('blue') axes2.spines['right'].set_color('red') axes1.set_xlabel('Hz') axes1.set_ylabel('Magnitude') axes2.set_ylabel('Phase angle') axes2.tick_params('y', color = 'red', labelcolor = 'red') axes2.yaxis.label.set_color('red') axes2.plot(self.xaxis, np.angle(data, deg = True), color = 'red', label = 'Phase angle') self.cursor = datacursor(axes = self.figure.get_axes(), formatter = LabelFormatter(), display = 'multiple') self.canvas.draw() def plot_open(self): self.plot_magphase(self.open[0:self.sweep_size]) def plot_short(self): self.plot_magphase(self.short[0:self.sweep_size]) def plot_load(self): self.plot_magphase(self.load[0:self.sweep_size]) def plot_dut(self): self.plot_magphase(self.dut[0:self.sweep_size]) def plot_smith_grid(self, axes, color): load = 50.0 ticks = np.array([0.0, 0.2, 0.5, 1.0, 2.0, 5.0]) for tick in ticks * load: axis = np.logspace(-4, np.log10(1.0e3), 200) * load z = tick + 1.0j * axis gamma = (z - load)/(z + load) axes.plot(gamma.real, gamma.imag, color = color, linewidth = 0.4, alpha = 0.3) axes.plot(gamma.real, -gamma.imag, color = color, linewidth = 0.4, alpha = 0.3) z = axis + 1.0j * tick gamma = (z - load)/(z + load) axes.plot(gamma.real, gamma.imag, color = color, linewidth = 0.4, alpha = 0.3) axes.plot(gamma.real, -gamma.imag, color = color, linewidth = 0.4, alpha = 0.3) if tick == 0.0: axes.text(1.0, 0.0, u'\u221E', color = color, ha = 'left', va = 'center', clip_on = True, fontsize = 18.0) axes.text(-1.0, 0.0, u'0\u03A9', color = color, ha = 'left', va = 'bottom', clip_on = True, fontsize = 12.0) continue lab = u'%d\u03A9' % tick x = (tick - load) / (tick + load) axes.text(x, 0.0, lab, color = color, ha = 'left', va = 'bottom', clip_on = True, fontsize = 12.0) lab = u'j%d\u03A9' % tick z = 1.0j * tick gamma = (z - load)/(z + load) * 1.05 x = gamma.real y = gamma.imag angle = np.angle(gamma) * 180.0 / np.pi - 90.0 axes.text(x, y, lab, color = color, ha = 'center', va = 'center', clip_on = True, rotation = angle, fontsize = 12.0) lab = u'-j%d\u03A9' % tick axes.text(x, -y, lab, color = color, ha = 'center', va = 'center', clip_on = True, rotation = -angle, fontsize = 12.0) def plot_smith(self): if self.cursor is not None: self.cursor.hide().disable() matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(left = 0.0, bottom = 0.0, right = 1.0, top = 1.0) axes1 = self.figure.add_subplot(111) self.plot_smith_grid(axes1, 'blue') gamma = self.gamma() plot, = axes1.plot(gamma.real, gamma.imag, color = 'red') axes1.axis('equal') axes1.set_xlim(-1.12, 1.12) axes1.set_ylim(-1.12, 1.12) axes1.xaxis.set_visible(False) axes1.yaxis.set_visible(False) for loc, spine in axes1.spines.items(): spine.set_visible(False) self.cursor = datacursor(plot, formatter = SmithFormatter(self.xaxis), display = 'multiple') self.canvas.draw() def plot_imp(self): self.plot_magphase(self.impedance()) def plot_rc(self): self.plot_magphase(self.gamma()) def plot_swr(self): if self.cursor is not None: self.cursor.hide().disable() matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(left = 0.12, bottom = 0.12, right = 0.88, top = 0.98) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.set_xlabel('Hz') axes1.set_ylabel('SWR') magnitude = np.absolute(self.gamma()) swr = np.maximum(1.0, np.minimum(100.0, (1.0 + magnitude) / np.maximum(1.0e-20, 1.0 - magnitude))) axes1.plot(self.xaxis, swr, color = 'blue', label = 'SWR') self.cursor = datacursor(axes = self.figure.get_axes(), formatter = LabelFormatter(), display = 'multiple') self.canvas.draw() def plot_rl(self): if self.cursor is not None: self.cursor.hide().disable() matplotlib.rcdefaults() self.figure.clf() self.figure.subplots_adjust(left = 0.12, bottom = 0.12, right = 0.88, top = 0.98) axes1 = self.figure.add_subplot(111) axes1.cla() axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix)) axes1.set_xlabel('Hz') axes1.set_ylabel('Return loss, dB') magnitude = np.absolute(self.gamma()) axes1.plot(self.xaxis, 20.0 * np.log10(magnitude), color = 'blue', label = 'Return loss') self.cursor = datacursor(axes = self.figure.get_axes(), formatter = LabelFormatter(), display = 'multiple') self.canvas.draw() def write_cfg(self): dialog = QFileDialog(self, 'Write configuration settings', '.', '*.ini') dialog.setDefaultSuffix('ini') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() settings = QSettings(name[0], QSettings.IniFormat) self.write_cfg_settings(settings) def read_cfg(self): dialog = QFileDialog(self, 'Read configuration settings', '.', '*.ini') dialog.setDefaultSuffix('ini') dialog.setAcceptMode(QFileDialog.AcceptOpen) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() settings = QSettings(name[0], QSettings.IniFormat) self.read_cfg_settings(settings) def write_cfg_settings(self, settings): settings.setValue('addr', self.addrValue.text()) settings.setValue('start', self.startValue.value()) settings.setValue('stop', self.stopValue.value()) settings.setValue('rate', self.rateValue.currentIndex()) settings.setValue('corr', self.corrValue.value()) size = self.sizeValue.value() settings.setValue('size', size) for i in range(0, size): settings.setValue('open_real_%d' % i, float(self.open.real[i])) settings.setValue('open_imag_%d' % i, float(self.open.imag[i])) for i in range(0, size): settings.setValue('short_real_%d' % i, float(self.short.real[i])) settings.setValue('short_imag_%d' % i, float(self.short.imag[i])) for i in range(0, size): settings.setValue('load_real_%d' % i, float(self.load.real[i])) settings.setValue('load_imag_%d' % i, float(self.load.imag[i])) for i in range(0, size): settings.setValue('dut_real_%d' % i, float(self.dut.real[i])) settings.setValue('dut_imag_%d' % i, float(self.dut.imag[i])) def read_cfg_settings(self, settings): self.addrValue.setText(settings.value('addr', '192.168.1.100')) self.startValue.setValue(settings.value('start', 100, type = int)) self.stopValue.setValue(settings.value('stop', 60000, type = int)) self.rateValue.setCurrentIndex(settings.value('rate', 0, type = int)) self.corrValue.setValue(settings.value('corr', 0, type = int)) size = settings.value('size', 600, type = int) self.sizeValue.setValue(size) for i in range(0, size): real = settings.value('open_real_%d' % i, 0.0, type = float) imag = settings.value('open_imag_%d' % i, 0.0, type = float) self.open[i] = real + 1.0j * imag for i in range(0, size): real = settings.value('short_real_%d' % i, 0.0, type = float) imag = settings.value('short_imag_%d' % i, 0.0, type = float) self.short[i] = real + 1.0j * imag for i in range(0, size): real = settings.value('load_real_%d' % i, 0.0, type = float) imag = settings.value('load_imag_%d' % i, 0.0, type = float) self.load[i] = real + 1.0j * imag for i in range(0, size): real = settings.value('dut_real_%d' % i, 0.0, type = float) imag = settings.value('dut_imag_%d' % i, 0.0, type = float) self.dut[i] = real + 1.0j * imag def write_csv(self): dialog = QFileDialog(self, 'Write csv file', '.', '*.csv') dialog.setDefaultSuffix('csv') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') gamma = self.gamma() size = self.sizeValue.value() fh.write('frequency;open.real;open.imag;short.real;short.imag;load.real;load.imag;dut.real;dut.imag\n') for i in range(0, size): fh.write('0.0%.8d;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f\n' % (self.xaxis[i], self.open.real[i], self.open.imag[i], self.short.real[i], self.short.imag[i], self.load.real[i], self.load.imag[i], self.dut.real[i], self.dut.imag[i])) fh.close() def write_s1p(self): dialog = QFileDialog(self, 'Write s1p file', '.', '*.s1p') dialog.setDefaultSuffix('s1p') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') gamma = self.gamma() size = self.sizeValue.value() fh.write('# GHz S MA R 50\n') for i in range(0, size): fh.write('0.0%.8d %8.6f %7.2f\n' % (self.xaxis[i], np.absolute(gamma[i]), np.angle(gamma[i], deg = True))) fh.close() def write_s2p(self): dialog = QFileDialog(self, 'Write s2p file', '.', '*.s2p') dialog.setDefaultSuffix('s2p') dialog.setAcceptMode(QFileDialog.AcceptSave) dialog.setOptions(QFileDialog.DontConfirmOverwrite) if dialog.exec() == QDialog.Accepted: name = dialog.selectedFiles() fh = open(name[0], 'w') gain = self.gain() gamma = self.gamma() size = self.sizeValue.value() fh.write('# GHz S MA R 50\n') for i in range(0, size): fh.write('0.0%.8d %8.6f %7.2f %8.6f %7.2f 0.000000 0.00 0.000000 0.00\n' % (self.xaxis[i], np.absolute(gamma[i]), np.angle(gamma[i], deg = True), np.absolute(gain[i]), np.angle(gain[i], deg = True))) fh.close()
def run(self): socket = QTcpSocket() if not socket.setSocketDescriptor(self.socketId): #self.emit(SIGNAL("error(int)"), socket.error()) self.error.connect(socket.error) return while socket.state() == QAbstractSocket.ConnectedState: nextBlockSize = 0 stream = QDataStream(socket) stream.setVersion(QDataStream.Qt_5_7) if (socket.waitForReadyRead() and socket.bytesAvailable() >= SIZEOF_UINT16): nextBlockSize = stream.readUInt16() else: self.sendError(socket, "Cannot read client request") return if socket.bytesAvailable() < nextBlockSize: if (not socket.waitForReadyRead(60000) or socket.bytesAvailable() < nextBlockSize): self.sendError(socket, "Cannot read client data") return action = "" room = "" date = QDate() action=stream.readQString() if action in ("BOOK", "UNBOOK"): room=stream.readQString() stream >> date try: Thread.lock.lockForRead() bookings = Bookings.get(date.toPyDate()) finally: Thread.lock.unlock() uroom = str(room) if action == "BOOK": newlist = False try: Thread.lock.lockForRead() if bookings is None: newlist = True finally: Thread.lock.unlock() if newlist: try: Thread.lock.lockForWrite() bookings = Bookings[date.toPyDate()] finally: Thread.lock.unlock() error = None insert = False try: Thread.lock.lockForRead() if len(bookings) < MAX_BOOKINGS_PER_DAY: if uroom in bookings: error = "Cannot accept duplicate booking" else: insert = True else: error = "{0} is fully booked".format(date.toString(Qt.ISODate)) finally: Thread.lock.unlock() if insert: try: Thread.lock.lockForWrite() bisect.insort(bookings, uroom) finally: Thread.lock.unlock() self.sendReply(socket, action, room, date) else: self.sendError(socket, error) elif action == "UNBOOK": error = None remove = False try: Thread.lock.lockForRead() if bookings is None or uroom not in bookings: error = "Cannot unbook nonexistent booking" else: remove = True finally: Thread.lock.unlock() if remove: try: Thread.lock.lockForWrite() bookings.remove(uroom) finally: Thread.lock.unlock() self.sendReply(socket, action, room, date) else: self.sendError(socket, error) else: self.sendError(socket, "Unrecognized request") socket.waitForDisconnected() try: Thread.lock.lockForRead() printBookings() finally: Thread.lock.unlock()
class Client(QDialog): def __init__(self): super().__init__() self.tcpSocket = QTcpSocket(self) self.blockSize = 0 self.makeRequest() self.tcpSocket.waitForConnected(1000) # send any message you like it could come from a widget text. self.tcpSocket.write(b'hello') self.tcpSocket.readyRead.connect(self.dealCommunication) self.tcpSocket.error.connect(self.displayError) def makeRequest(self): HOST = '127.0.0.1' PORT = 8000 self.tcpSocket.connectToHost(HOST, PORT, QIODevice.ReadWrite) def dealCommunication(self): instr = QDataStream(self.tcpSocket) instr.setVersion(QDataStream.Qt_5_0) if self.blockSize == 0: if self.tcpSocket.bytesAvailable() < 2: return self.blockSize = instr.readUInt16() if self.tcpSocket.bytesAvailable() < self.blockSize: return # Print response to terminal, we could use it anywhere else we wanted. print(str(instr.readString(), encoding='ascii')) def displayError(self, socketError): if socketError == QAbstractSocket.RemoteHostClosedError: pass else: print(self, "The following error occurred: %s." % self.tcpSocket.errorString())