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