def __init__(self):
super(SerialWidget, self).__init__()
self.com = QSerialPort()
self.sendCnt = 0
self.recvCnt = 0
self.serialStatus = False
self.initUI()
self.detectSerialStatus()
self.signalSlot()
def __init__(self):
super(RPMPlotter, self).__init__()
# Setupui
self.setupUi(self)
# Create a serial port
self.__serialPort = QSerialPort()
# Setup Serialport
# We are using USB serial driver, so the baud rate doesn't matter
self.__serialPort.setBaudRate(QSerialPort.Baud115200,
QSerialPort.Input)
# Get the list of all available serial ports
portsList = QSerialPortInfo.availablePorts()
# Only connect to Chibios port
chibiOsPort = None
self.setWindowTitle("Experiment Data Collector")
for port in portsList:
if ("ChibiOS" in port.description()):
chibiOsPort = port
print(chibiOsPort.description())
# Check of the device is connected.
if (chibiOsPort is None):
# We didn't find anything
statusString = "Cannot find Chibios based device."
print(statusString)
else:
# Set the serial port
self.__serialPort.setPort(chibiOsPort)
self.__serialPort.setDataBits(QSerialPort.Data8)
self.__serialPort.setFlowControl(QSerialPort.NoFlowControl)
self.__serialPort.setParity(QSerialPort.NoParity)
self.__serialPort.setStopBits(QSerialPort.OneStop)
# Connect signals and slots
self.__serialPort.readyRead.connect(self.__onSerialPortReadyRead)
self.startButton.clicked.connect(self.onStartButtonClicked)
self.lineEdit.returnPressed.connect(self.onReferenceValueChanged)
# Open the device
self.__serialPort.open(QIODevice.ReadWrite)
# Initialize variables
# We track the reference and draw it as a line.
self.__referenceArray = []
# Timestamp in seconds
self.__timeStampArray = []
# RPM value
self.__rpmArray = []
# Voltage provided to the motor
self.__voltageValue = []
## Curves
self.__rpmCurve = pg.PlotCurveItem()
self.__rpmCurve.setPen(pg.mkPen(color=(3, 39, 28), width=1.2))
self.__referenceCurve = pg.PlotCurveItem()
self.__referenceCurve.setPen(
pg.mkPen(color=(214, 118, 17), width=1.2,
style=Qt.DashDotLine))
self.graphicsView.addItem(self.__rpmCurve)
self.graphicsView.addItem(self.__referenceCurve)
def __init__(self):
super().__init__()
self.com = QSerialPort()
self.Layout()
self.CreateSignalSolt()
self.RefreshCom()
self.encoding = 'utf-8'
self.recvCount = 0
self.sendCount = 0
def __init__(self, parent=None):
super(Serial, self).__init__(parent)
self.setupUi(self)
self.setWindowTitle("串口助手<V1.0> by-FXC") # 设置标题
self._num_send = 0 # 发送数据量
self._num_receive = 0 # 接收数据量
self._serial = QSerialPort(self) # 用于连接串口的对象
self._single_slot() # 连接信号与槽
self.get_available_ports() # 获取可用的串口列表
self.set_statusbar() # 设置状态栏
self.plainTextEdit_send.setPlainText("hello world!")
def initSerial(self, str_com):
self.data_zigbee_list = []
# 初始化串口
self.ser_data = QSerialPort(STR_COM,
baudRate=QSerialPort.Baud115200,
readyRead=self.receive)
self.ser_data.open(QIODevice.ReadWrite)
if self.ser_data.isOpen():
print('串口开启成功！')
else:
print('串口打开失败……')
def __init__(self, port_name=None, parent=None):
super(SerialPort, self).__init__(parent)
self.serial = QSerialPort()
self.port_name = port_name
self.baud_rate = 57600
self.data_bits = QSerialPort.Data8
self.parity = QSerialPort.NoParity
self.stop_bits = QSerialPort.OneStop
self.flow_control = QSerialPort.NoFlowControl
self.isserial_open = False
def __init__(self, *args, **kwargs):
super(QtCore.QObject, self).__init__(*args, **kwargs)
self.serial = QSerialPort()
port = "/dev/ttyUSB0"
self.serial.setPortName(port)
if self.serial.open(QtCore.QIODevice.ReadWrite):
self.serial.setDataTerminalReady(True)
self.serial.setBaudRate(115200)
self.serial.readyRead.connect(self.on_serial_read)
else:
print("Failed to open serial port")
def __init__(self,parent=None):
super(MyPort, self).__init__(parent)
self.ser=None
self.portOpen=False
self.headerList = ['GPHPD', 'GTIMU', 'GPFPD']
self.portInfo=QSerialPortInfo()
self.availablePorts=[]
self.port=QSerialPort()
self.paritySet={'even':QSerialPort.EvenParity,'odd':QSerialPort.OddParity,'none':QSerialPort.NoParity}
self.time=QTimer()
self.time.timeout.connect(self.updatePort)
self.time.start(500)
def searchPort(self):
"""
搜索可用的串口，并存储起来：{串口名：串口信息}
"""
info_list = QSerialPortInfo.availablePorts()
self.port = {}
for info in info_list:
serial = QSerialPort()
serial.setPort(info)
if serial.open(QIODevice.ReadWrite):
self.port[serial.portName()] = info
serial.close()
def __init__(self, parent=None):
super().__init__()
self.parent = parent
self.results = P1Results(0, 0, 0, 0, 0, 0, 0)
self.serial = QSerialPort(self)
self.serialbuffer = [] # empty list
# self.serialbuffer = bytearray(b'')
self.lastKernCmd = b""
# make connections(see Terminal example)
self.serial.error.connect(self.handleError)
self.serial.readyRead.connect(self.readData)
def connect_to_serial_port(self):
port = self.find_serial_port()
self.serial_port = QSerialPort(port)
# Try to open the port
if self.serial_port.open(QSerialPort.ReadWrite):
self.serial_port.setBaudRate(115200, QSerialPort.AllDirections)
self.serial_port.setParity(QSerialPort.NoParity)
self.serial_port.setDataBits(QSerialPort.Data8)
self.serial_port.setStopBits(QSerialPort.OneStop)
self.serial_port.setFlowControl(QSerialPort.HardwareControl)
else:
self.serial_port = None
raise GpsdoError("Error opening " + self.port_name)
def __init__(self, hdr, portName):
super(SerialConnection, self).__init__(None)
self.hdr = hdr
self.settings = QtCore.QSettings("MsgTools",
"MessageServer/SerialPlugin")
# button to open/close serial port
self.openCloseButton = QtWidgets.QPushButton("button")
self.openCloseButton.pressed.connect(self.openCloseSwitch)
# button select new serial port
self.selectPortButton = QtWidgets.QPushButton("Select Port")
self.selectPortButton.pressed.connect(self.selectPort)
self.statusLabel = QtWidgets.QLabel()
self.subscriptions = {}
self.subMask = 0
self.subValue = 0
self.isHardwareLink = True
# if port not specified, default to last used port
if not portName:
portName = self.settings.value("portName", None)
self.serialPort = QSerialPort(portName)
self.serialPort.setBaudRate(QSerialPort.Baud115200)
self.serialPort.setFlowControl(QSerialPort.NoFlowControl)
self.serialPort.setParity(QSerialPort.NoParity)
self.serialPort.setDataBits(QSerialPort.Data8)
self.serialPort.setStopBits(QSerialPort.OneStop)
self.rxBuffer = bytearray()
self.gotHeader = 0
self.rxMsgCount = 0
self.serialPort.readyRead.connect(self.onReadyRead)
self.name = "Serial " + self.serialPort.portName()
self.hdrTranslator = HeaderTranslator(hdr, Messaging.hdr)
self.serialStartSeqField = Messaging.findFieldInfo(
hdr.fields, "StartSequence")
if self.serialStartSeqField != None:
self.startSequence = int(hdr.GetStartSequence.default)
self.startSeqSize = int(hdr.GetStartSequence.size)
try:
self.hdrCrcRegion = int(hdr.GetHeaderChecksum.offset)
except AttributeError:
self.hdrCrcRegion = None
self.tmpRxHdr = ctypes.create_string_buffer(0)
def __init__(self):
super().__init__()
self.cell = 0
self.csv = open("Cell_ " + str(self.cell) + "_test.csv", 'w+')
self.csv.write("time,voltage,\r\n")
self.timer = QTimer()
self.timer.timeout.connect(self.readSerialChar)
for i in QSerialPortInfo.availablePorts():
print(i.portName())
portname = input()
self.SerialPort = QSerialPort()
self.connectSerial(portname)
def __init__(self):
super().__init__()
self.serial = QSerialPort()
self.line = ""
port = "/dev/ttyUSB0"
self.serial.setPortName(port)
if self.serial.open(QtCore.QIODevice.ReadWrite):
self.serial.setDataTerminalReady(True)
self.serial.setBaudRate(115200)
self.serial.readyRead.connect(self.on_serial_read)
self.serial.write(b"\r\n")
else:
print("Failed to open serial port")
def send_config(self):
dlg = SendConfigDialog()
if dlg.exec_() == QDialog.Accepted:
if dlg.commands:
try:
self.serial = QSerialPort(self.cbxPort.currentData())
self.serial.setBaudRate(115200)
self.serial.open(QIODevice.ReadWrite)
self.serial.readyRead.connect(self.on_serial_read)
bytes_sent = self.serial.write(bytes(dlg.commands, 'utf8'))
except Exception as e:
QMessageBox.critical(self, "COM Port error", e)
else:
QMessageBox.information(self, "Done", "Nothing to send")
def __init__(self, parent=None):
super(Serial, self).__init__(parent)
self.setupUi(self)
self.setWindowTitle("串口调试助手V1.0")
self.setWindowIcon(SerialIcon().getQIcon())
self.numSend = 0
self.numRcv = 0
self.timerSend = None
self.ports = {}
self.serial = QSerialPort()
self.initTimerSend()
self.setupSigSlot()
self.setSerialStatusBar()
self.setupThread()
self.bytesWritten = 0
def __init__(self, params={}, parent=None):
'''
Constructor
'''
super(SerialDevice, self).__init__(params, parent)
self.iodevice = QSerialPort()
self.reconnect = int(params.get('Reconnect', 1000))
self.serialPort = params.get('SerialPort', None)
self.baudrate = int(params.get('Baudrate', QSerialPort.Baud9600))
self.databits = int(params.get('Databits', QSerialPort.Data8))
self.parity = int(params.get('Parity', QSerialPort.NoParity))
self.stopbits = int(params.get('Stopbits', QSerialPort.OneStop))
self.flowControl = int(params.get('FlowControl', QSerialPort.NoFlowControl))
self.iodevice.readyRead.connect(self.readyRead)
self.buffer = bytearray()
def open_serial_port(self, config):
try:
serial_port = QSerialPort()
serial_port.setPortName(config.port)
#Setting the AllDirections flag is supported on all platforms. Windows supports only this mode.
serial_port.setBaudRate(config.baudrate, QSerialPort.AllDirections)
serial_port.setParity(config.parity)
serial_port.setStopBits(config.stopbits)
serial_port.setDataBits(config.bytesize)
serial_port.setFlowControl(config.flowcontrol)
serial_port.open(QSerialPort.ReadWrite)
return serial_port
except Exception as e:
log.error("{}".format(traceback.format_exc()))
return None
def open_serial_port(name):
try:
serial_port = QSerialPort()
serial_port.setPortName(name)
serial_port.setBaudRate(QSerialPort.Baud115200,
QSerialPort.AllDirections)
serial_port.setParity(QSerialPort.NoParity)
serial_port.setStopBits(QSerialPort.OneStop)
serial_port.setDataBits(QSerialPort.Data8)
serial_port.setFlowControl(QSerialPort.NoFlowControl)
serial_port.open(QSerialPort.ReadWrite)
return serial_port
except Exception as e:
print("open_serial_port", e)
return None
def CreateItems(self):
self.com = QSerialPort()
self.lblPort = QLabel('串 口')
self.lblBaud = QLabel('波特率')
self.lblParity = QLabel('校验位')
self.lblWordLen = QLabel('数据位')
self.lblStopBits = QLabel('停止位')
self.cmbPort = QComboBox()
self.cmbBaud = QComboBox()
self.cmbParity = QComboBox()
self.cmbWordLen = QComboBox()
self.cmbStopBits = QComboBox()
self.btnOpenPort = QPushButton('打开串口')
self.btnClosePort = QPushButton('关闭串口')
# self.btnOpenPort.setFont(QFont('Arial', 15))
self.btnOpenPort.setFixedHeight(35)
self.btnClosePort.setFixedHeight(35)
font = QFont()
font.setPixelSize(15)
self.btnOpenPort.setFont(font)
self.btnClosePort.setFont(font)
self.btnClosePort.setEnabled(False)
self.chcHexRecv = QCheckBox('十六进制接收')
self.chcWrap = QCheckBox('自动换行')
self.chcAutoClear = QCheckBox('自动清空')
self.chcAutoSave = QCheckBox('自动保存')
self.btnClear = QPushButton('清空')
self.lblAddr = QLabel('地址')
self.txtAddr = QLineEdit()
self.btnSaveAs = QPushButton('选择...')
self.chcHexSend = QCheckBox('十六进制发送')
self.chcAutoSend = QCheckBox('自动发送')
self.txtAutoSend = QLineEdit()
self.lblAutoSend = QLabel('秒')
self.txtRecv = QPlainTextEdit()
self.txtSend = QPlainTextEdit()
self.btnSend = QPushButton('发送')
self.txtSend.setFixedHeight(100)
self.btnSend.setFixedHeight(35)
def handleButtonOpenPort(self):
self.serialPort = QSerialPort(self.comboBox_CfgPorts.currentData(),
None)
self.serialPort.setBaudRate(QSerialPort.Baud115200)
self.serialPort.setParity(QSerialPort.NoParity)
self.serialPort.setFlowControl(QSerialPort.NoFlowControl)
self.serialPort.setStopBits(QSerialPort.OneStop)
self.serialPort.setDataBits(QSerialPort.Data8)
self.serialPort.readyRead.connect(self.handleSerialReceiveData)
if (self.serialPort.open(QIODevice.ReadWrite) == True):
self.label_CfgCurrentMode.setEnabled(True)
self.label_CfgSelectMode.setEnabled(True)
self.comboBox_CfgModes.setEnabled(True)
self.pushButton_CfgSelectMode.setEnabled(True)
def __init__(self, parent=None):
super().__init__(parent)
# TODO: define port at a better location
# TODO: check for port opening / writing exceptions
self.serial = QSerialPort()
self.serial.readyRead.connect(self.serialRead)
self.serial.setPortName("COM8")
self.serial.open(QIODevice.ReadWrite)
self.serial.setBaudRate(115200)
self.serial.setDataBits(8)
self.serial.setParity(QSerialPort.NoParity)
self.serial.setStopBits(1)
self.serial.setFlowControl(QSerialPort.NoFlowControl)
assert self.serial.error() == QSerialPort.NoError
self.serial.clear(QSerialPort.Input)
def run(self):
if not self._isRunning:
self._isRunning = True
self.serPort = QSerialPort()
self.serPort.setBaudRate(9600)
self.serPort.setPortName(self.port)
self.serPort.open(QIODevice.ReadWrite)
self.serPort.readyRead.connect(self.dataReady)
while self._isRunning == True:
QThread.msleep(self.delay)
if self.Temperatura != 0 and self.Humidity != 0 and self.Pressure != 0:
self.change_value.emit(self.Temperatura, self.Humidity,
self.Pressure)
QApplication.processEvents()
def connectGPS(self, portname):
if not self.isConnected:
self._currentport = portname
if portname == 'scan' or portname == '':
portname = ''
self.detector = QgsGpsDetector(portname)
self.detector.detected.connect(self._gpsfound)
self.detector.detectionFailed.connect(self.gpsfailed)
self.isConnectFailed = False
self.detector.advance()
elif portname.startswith("COM"):
self.device = QSerialPort(portname)
baudrates = [
QSerialPort.Baud4800, QSerialPort.Baud9600,
QSerialPort.Baud38400, QSerialPort.Baud57600,
QSerialPort.Baud115200
]
flow = config.get("gps", {}).get("flow_control", None)
rate = config.get("gps", {}).get("rate", None)
if rate:
baudrates = [rate]
for rate in baudrates:
self.device.setBaudRate(rate)
if flow == "hardware":
log("using hardware flow control for GPS")
self.device.setFlowControl(QSerialPort.HardwareControl)
elif flow == "software":
log("using software flow control for GPS")
self.device.setFlowControl(QSerialPort.SoftwareControl)
else:
self.device.setFlowControl(QSerialPort.NoFlowControl)
self.device.setParity(QSerialPort.NoParity)
self.device.setDataBits(QSerialPort.Data8)
self.device.setStopBits(QSerialPort.OneStop)
if self.device.open(QIODevice.ReadWrite):
log("Connection opened with {0}".format(
self.device.baudRate()))
self.gpsConn = QgsNmeaConnection(self.device)
self._gpsfound(self.gpsConn)
break
else:
del self.device
continue
else:
# If we can't connect to any GPS just error out
self.gpsfailed.emit()
def __init__(self):
super(ExperimentDataCollector, self).__init__()
# Setupui
self.setupUi(self)
# Create a serial port
self.__serialPort = QSerialPort()
# Setup Serialport
# We are using USB serial driver, so the baud rate doesn't matter
self.__serialPort.setBaudRate(QSerialPort.Baud1200, QSerialPort.Input)
# Get the list of all available serial ports
portsList = QSerialPortInfo.availablePorts()
# Only connect to Chibios port
chibiOsPort = None
self.setWindowTitle("Experiment Data Collector")
for port in portsList:
if ("ChibiOS" in port.description()):
chibiOsPort = port
print(chibiOsPort.description())
# Check of the device is connected.
if (chibiOsPort is None):
# We didn't find anything
statusString = "Cannot find Chibios based device."
print(statusString)
else:
# Set the serial port
self.__serialPort.setPort(chibiOsPort)
self.__serialPort.setDataBits(QSerialPort.Data8)
self.__serialPort.setFlowControl(QSerialPort.NoFlowControl)
self.__serialPort.setParity(QSerialPort.NoParity)
self.__serialPort.setStopBits(QSerialPort.OneStop)
# Connect signals and slots
self.__serialPort.readyRead.connect(self.__onSerialPortReadyRead)
self.startButton.clicked.connect(self.__onStartButtonClicked)
# Open the device
self.__serialPort.open(QIODevice.ReadWrite)
# Initialize variables
# Timestamp in seconds
self.__timeStampArray = []
# Angle in degrees
self.__angleArray = []
# Add the curves as well for plotting
self.__angleDataCurve = pg.PlotCurveItem()
self.graphicsView.addItem(self.__angleDataCurve)
# Open csv file to write
csvFileObj = open("Experiment_Rpm.csv", mode='w', newline='')
self.__csvWriterObj = csv.writer(csvFileObj)
self.__csvWriterObj.writerow(['Timestamp', 'Angle in deg'])
def __init__(self, port, parent=None):
super().__init__(parent)
self.setAcceptRichText(False)
self.setReadOnly(False)
self.setLineWrapMode(QTextEdit.NoWrap)
self.setObjectName('replpane')
# open the serial port
self.serial = QSerialPort(self)
self.serial.setPortName(port)
self.serial.setBaudRate(115200)
print(self.serial.open(QIODevice.ReadWrite))
self.serial.readyRead.connect(self.on_serial_read)
self.serial_input_buffer = b''
# clear the text
self.clear()
def button_close_cb(self):
print("close")
port = self.comboBox_com.currentText()[:5]
print(port)
self.com = QSerialPort()
self.com.setPortName(port)
self.com.close()
self.comboBox_com.setDisabled(False)
# self.comboBox_baud.setDisabled(False)
# self.comboBox_databit.setDisabled(False)
# self.comboBox_checkbitbit.setDisabled(False)
# self.comboBox_stopbitbit.setDisabled(False)
self.pushButton_open.setDisabled(False)
self.pushButton_close.setDisabled(True)
pass
def __init__(self):
QWidget.__init__(self, flags=Qt.Widget)
# 위젯 선언
self.gb = QGroupBox(self.tr("Serial"))
self.cb_port = QComboBox()
self.cb_baud_rate = QComboBox()
# 시리얼 인스턴스 생성
# 시리얼 스레드 설정 및 시작
self.serial = QSerialPort()
self.serial_info = QSerialPortInfo()
self.serial_read_thread = SerialReadThread(self.serial)
self.serial_read_thread.received_data.connect(
lambda v: self.received_data.emit(v))
self.serial_read_thread.start()
self.init_widget()
def __init__(self, **kwargv):
""" """
# serial serial port object
serial = kwargv.get('serial', QSerialPort())
# settings
ports = self.avablesPorts()
if serial.portName() not in ports and len(ports):
self.name = ports[0]
else:
self.name = kwargv.get('name', serial.portName())
self.baudRate = kwargv.get('baud', serial.baudRate())
self.dataBits = kwargv.get('databit', serial.dataBits())
self.parity = kwargv.get('parity', serial.parity())
self.stopBits = kwargv.get('stopbit', serial.stopBits())
self.flowControl = kwargv.get('flow', serial.flowControl())
# send line delay in ms
self.linedelay = kwargv.get('linedelay', 200)
def send_config(self):
dlg = SendConfigDialog()
if dlg.exec_() == QDialog.Accepted:
if dlg.commands:
try:
self.port = QSerialPort(self.cbxPort.currentData())
self.port.setBaudRate(115200)
self.port.open(QIODevice.ReadWrite)
bytes_sent = self.port.write(bytes(dlg.commands, 'utf8'))
except Exception as e:
QMessageBox.critical(self, 'Error',
f'Port access error:\n{e}')
else:
self.settings.setValue('gbWifi', dlg.gbWifi.isChecked())
self.settings.setValue('AP', dlg.leAP.text())
self.settings.setValue('gbRecWifi',
dlg.gbRecWifi.isChecked())
self.settings.setValue('gbMQTT', dlg.gbMQTT.isChecked())
self.settings.setValue('Broker', dlg.leBroker.text())
self.settings.setValue('Port', dlg.sbPort.value())
self.settings.setValue('Topic', dlg.leTopic.text())
self.settings.setValue('FullTopic', dlg.leFullTopic.text())
self.settings.setValue('FriendlyName',
dlg.leFriendlyName.text())
self.settings.setValue('MQTTUser', dlg.leMQTTUser.text())
self.settings.setValue('gbModule',
dlg.gbModule.isChecked())
self.settings.setValue('ModuleMode',
dlg.rbgModule.checkedId())
self.settings.setValue('Module',
dlg.cbModule.currentText())
self.settings.setValue('Template', dlg.leTemplate.text())
self.settings.sync()
QMessageBox.information(
self, 'Done',
'Configuration sent ({} bytes)\nDevice will restart.'.
format(bytes_sent))
finally:
if self.port.isOpen():
self.port.close()
else:
QMessageBox.information(self, 'Done', 'Nothing to send')
