def _OpenSerialPort(self):
SerialPortName = self.UserInterface.SELSerialPort.itemText(
self.UserInterface.SELSerialPort.currentIndex()).split(" ")[0]
SerialPortBaudRate = int(
self.UserInterface.SELBaudRate.itemText(
self.UserInterface.SELBaudRate.currentIndex())[0:-5])
self.SerialPort = QtSerialPort.QSerialPort()
self.SerialPort.setPortName(SerialPortName)
self.SerialPort.setBaudRate(SerialPortBaudRate)
self.SerialPortInfo = QtSerialPort.QSerialPortInfo(self.SerialPort)
if not self.SerialPortInfo.isBusy():
try:
self.SerialPort.open(QtSerialPort.QSerialPort.ReadWrite)
self.SerialPort.readyRead.connect(self._SerialPortProcessor)
return True
except:
# Launch QTMessageBox
pass
else:
# Launch QTMessageBox
pass
return False
def refresh_ports(self):
ports = QtSerialPort.QSerialPortInfo().availablePorts()
ports_names = []
for i, port in enumerate(ports):
ports_names.append(port.portName())
self.ui.ports_box.clear()
self.ui.ports_box.addItems(ports_names)
def __init__(self, settings):
super().__init__()
self.setupUi(self)
self.settings = settings
self.serialInfo = QtSerialPort.QSerialPortInfo()
self.fillPortsParameters()
self.buttonBox.accepted.connect(self.updateSettings)
self.buttonBox.rejected.connect(self.close)
def save(self):
self.device.port = str(self.cbPorts.currentText())
self.device.info = QtSerialPort.QSerialPortInfo(self.device.port)
if self.device.advanced:
self.device.baudrate = str(self.cbBaudrate.currentText())
self.device.byteSize = str(self.cbByteSize.currentText())
self.device.parity = str(self.cbParity.currentText())
self.device.stopbits = str(self.cbStopbits.currentText())
self.device.flowControl = str(self.cbFlowControl.currentText())
def fillSerialPortFields(self):
self.ui.baudRateBox.insertItems(0, [str(x) for x in self.BAUDRATES])
self.ui.dataBitsBox.insertItems(0, [str(x) for x in self.DATABITS])
self.ui.stopBitsBox.insertItems(0, [str(x) for x in self.STOPBITS])
self.ui.parityBox.insertItems(0, [str(x) for x in self.PARITY])
ports = QtSerialPort.QSerialPortInfo().availablePorts()
self.ui.comPortBox.insertItems(0, [str(x.portName()) for x in ports])
baud_rate_index = self.ui.baudRateBox.findText("9600")
self.ui.baudRateBox.setCurrentIndex(baud_rate_index)
data_bits_index = self.ui.dataBitsBox.findText("8")
self.ui.dataBitsBox.setCurrentIndex(data_bits_index)
pass
def port_refresh(self):
self.table_port.clearContents()
available = QtSerialPort.QSerialPortInfo().availablePorts()
cur_row = 0
for x in available:
self.table_port.setItem(cur_row, 0,
QTableWidgetItem(str(x.portName())))
self.table_port.setItem(cur_row, 1,
QTableWidgetItem(str(x.description())))
self.table_port.setItem(cur_row, 2,
QTableWidgetItem(str(x.isBusy())))
self.table_port.setItem(cur_row, 3,
QTableWidgetItem(str(x.isValid())))
cur_row += 1
def __init__(self, xmlAttributes):
super(SerialDevice, self).__init__(xmlAttributes)
self.commands = []
for item in range(1, len(xmlAttributes)):
self.commands.append(Command(xmlAttributes[item], self.name))
self.port = xmlAttributes[0].value('Port')
self.info = QtSerialPort.QSerialPortInfo(self.port)
self.FlowControl = {
'None': QtSerialPort.QSerialPort.NoFlowControl,
'Hardware': QtSerialPort.QSerialPort.HardwareControl,
'Software': QtSerialPort.QSerialPort.SoftwareControl,
'Unknown': QtSerialPort.QSerialPort.UnknownFlowControl
}
self.Parity = {
'None': QtSerialPort.QSerialPort.NoParity,
'Even': QtSerialPort.QSerialPort.EvenParity,
'Odd': QtSerialPort.QSerialPort.OddParity,
'Mark': QtSerialPort.QSerialPort.MarkParity,
'Space': QtSerialPort.QSerialPort.SpaceParity
}
self.StopBits = {
'1': QtSerialPort.QSerialPort.OneStop,
'1.5': QtSerialPort.QSerialPort.OneAndHalfStop,
'2': QtSerialPort.QSerialPort.TwoStop
}
self.DataBits = {
'5': QtSerialPort.QSerialPort.Data5,
'6': QtSerialPort.QSerialPort.Data6,
'7': QtSerialPort.QSerialPort.Data7,
'8': QtSerialPort.QSerialPort.Data8
}
self.baudrate = str(xmlAttributes[0].value('Baudrate'))
self.byteSize = str(xmlAttributes[0].value('ByteSize'))
self.parity = str(xmlAttributes[0].value('Parity'))
self.stopbits = str(xmlAttributes[0].value('Stopbits'))
self.flowControl = str(xmlAttributes[0].value('FlowControl'))
self.terminate = bytes(xmlAttributes[0].value('Terminate'),
'utf-8').decode('unicode_escape')
if str(xmlAttributes[0].value('Advanced')) == 'True':
self.advanced = True
else:
self.advanced = False
def get_port_names(self):
ports = QtSerialPort.QSerialPortInfo().availablePorts()
return ports
pass
def rescan_ports(self):
self.ui.comPortBox.clear()
ports = QtSerialPort.QSerialPortInfo().availablePorts()
self.ui.comPortBox.insertItems(0, [str(x.portName()) for x in ports])
self.returnPorts.emit(ports)
pass
def __init__(self, parent=None):
super(Monitor, self).__init__(parent)
uic.loadUi(__file__.replace('.py', '.ui'), self)
self.terminalTextEdit.clear()
self.commandTab.setDisabled(True)
self.autoMeasureCheckBox.setDisabled(True)
self.autoMeasureSpinBox.setDisabled(True)
self.executeButton.clicked.connect(self.execute_command)
self.connectionButton.clicked.connect(self.connection_button_clicked)
self.clearTerminalPushButton.clicked.connect(
self.clear_terminal_button_clicked)
self.muteTerminalCheckBox.toggled.connect(self.terminal_mute_toggled)
self.fileSystemWatcher = QtCore.QFileSystemWatcher()
if self.detect_OS() == 'linux':
self.fileSystemWatcher.addPath(r'/dev')
self.fileSystemWatcher.directoryChanged.connect(
self.linux_watchdog)
self.serial = QtSerialPort.QSerialPort()
self.serial.readyRead.connect(self.receive)
self.serial_receive_buffer = b''
self.serialPortInfo = QtSerialPort.QSerialPortInfo()
self.commands_by_code = {}
self.commands_by_name = {}
display_list = self.load_commands()
self.commandComboBox.clear()
self.commandComboBox.insertItems(0, display_list)
self.commandComboBox.adjustSize()
self.commandComboBox.setCurrentText('get measurement')
self.CRC_CCITT = crcmod.mkCrcFun(0x11021, 0, False, 0)
self.rail_list = [
'RAIL0', 'P12V0D', 'RAIL1', 'RAIL2', 'P25V0D', 'P17V0D', 'N7V0D',
'P15V0A', 'N15V0A', 'P5V0D', 'P5V0A', 'N5V0A', 'P3V3D', 'P5V0R',
'GND'
]
self.setting_list = [
'VGAIN', 'VOFFSET', 'IGAIN', 'IOFFSET', 'VLLIM', 'VHLIM', 'ILLIM',
'IHLIM'
]
self.df_columns = []
self.settings = {}
for rail in self.rail_list:
self.settings[rail] = {}
self.df_columns.append(rail + '_VMON')
self.df_columns.append(rail + '_IMON')
for setting in self.setting_list:
if not (rail == 'GND' and setting.endswith('LIM')
and setting.startswith('I')):
self.settings[rail][setting] = 0.0
print(self.settings)
self.df = pd.DataFrame(columns=self.df_columns,
index=range(self.ChunkSize)).astype(np.float32)
self.df_row = 0
import time
from datetime import datetime
import matplotlib.pyplot as plt
import numpy as np
from PyQt5 import QtSerialPort
from src.hvps.Switchboard import SwitchBoard
if __name__ == '__main__':
comports = QtSerialPort.QSerialPortInfo().availablePorts()
portnames = [info.portName() for info in comports]
port = portnames[0]
hvps = SwitchBoard()
hvps.open(port)
Vset = 1000
SwMode = 1
relays = "off" # "on", "off", or "auto"
if relays == "on":
hvps.set_relays_on()
elif relays == "off":
hvps.set_relays_off()
elif relays == "auto":
hvps.set_relay_auto_mode()
hvps.set_switching_mode(SwMode)
data = np.ones((1520, 3))
idata = -1
