multiserialviewer 24.12.0__py3-none-any.whl

multiserialviewer/__init__.py

@@ -0,0 +1 @@
+from .__version__ import __version__

multiserialviewer/__main__.py

@@ -0,0 +1,12 @@
+import sys
+from multiserialviewer import __version__
+from multiserialviewer.application.application import Application
+
+
+def main() -> int | str:
+    app = Application(__version__, sys.argv)
+    return app.exec()
+
+
+if __name__ == '__main__':
+    sys.exit(main())

multiserialviewer/__version__.py

@@ -0,0 +1,13 @@
+# Version scheme:
+# YEAR.MONTH.COUNTER
+# YEAR, MONTH are two digits and zero-padded
+# COUNTER resets every month and starts with 0
+# For example:
+# - 23.09.0
+# - 23.09.1
+# - 23.10.0
+#
+# Development versions contain the DEV-COUNTER postfix:
+# - 24.01.0.DEV-1
+
+__version__ = '24.12.0'

multiserialviewer/application/application.py

@@ -0,0 +1,225 @@
+from PySide6.QtWidgets import QApplication
+from PySide6.QtCore import QSettings, QSize, Slot
+from typing import List
+from platformdirs import user_config_dir
+import pathlib
+import copy
+
+from multiserialviewer.gui.mainWindow import MainWindow
+from multiserialviewer.serial_data.serialDataReceiver import SerialDataReceiver
+from multiserialviewer.serial_data.serialDataProcessor import SerialDataProcessor
+from multiserialviewer.serial_data.serialConnectionSettings import SerialConnectionSettings
+from multiserialviewer.text_highlighter.textHighlighterConfig import TextHighlighterConfig
+from multiserialviewer.application.serialViewerController import SerialViewerController
+from multiserialviewer.application.proxyStyle import ProxyStyle
+
+
+
+
+class Application(QApplication):
+    NAME = 'MultiSerialViewer'
+
+    def __init__(self, version: str, arguments):
+        super().__init__(arguments)
+
+        self.config_dir = user_config_dir(appname=Application.NAME, roaming=False, ensure_exists=True, appauthor=False)
+        self.main_config_file_path = str(pathlib.PurePath(self.config_dir, 'multiserialviewer.ini'))
+        self.highlighter_config_file_path = str(pathlib.PurePath(self.config_dir, 'highlighter.ini'))
+
+        self.controller = {}
+        self.highlighterSettings: List[TextHighlighterConfig] = []
+
+        self.mainWindow = MainWindow(f'{Application.NAME} {version}')
+        self.mainWindow.signal_showSerialViewerCreateDialog.connect(self.showSerialViewerCreateDialog)
+        self.mainWindow.signal_createSerialViewer.connect(self.createSerialViewer)
+        self.mainWindow.signal_clearAll.connect(self.clearAll)
+        self.mainWindow.signal_connectionStateChanged.connect(self.changeConnectionState)
+        self.mainWindow.signal_aboutToBeClosed.connect(self.saveSettings)
+        self.mainWindow.signal_aboutToBeClosed.connect(self.saveSerialViewerSettings)
+        self.mainWindow.signal_aboutToBeClosed.connect(self.saveHighlighterSettings)
+        self.mainWindow.signal_aboutToBeClosed.connect(self.stopAllSerialViewer)
+        self.mainWindow.signal_editHighlighterSettings.connect(self.showHighlighterSettingsDialog)
+        self.mainWindow.signal_applyHighlighterSettings.connect(self.setHighlighterSettings)
+
+        self.loadSettings()
+        self.loadHighlighterSettings()
+        self.loadSerialViewerSettings()
+
+        self.setStyle(ProxyStyle())
+        self.mainWindow.show()
+
+    def initDefaultHighlighterSettings(self):
+        self.highlighterSettings = []
+
+        cfg = TextHighlighterConfig()
+        cfg.pattern = r'\[MSG: .* :MSG\]'
+        cfg.color_foreground = 'darkgreen'
+        cfg.color_background = 'transparent'
+        cfg.italic = False
+        cfg.bold = True
+        cfg.font_size = QApplication.font().pointSize()
+        self.highlighterSettings.append(cfg)
+
+        cfg = TextHighlighterConfig()
+        cfg.pattern = r'\[ERR: .* :ERR\]'
+        cfg.color_foreground = 'darkred'
+        cfg.color_background = 'transparent'
+        cfg.italic = False
+        cfg.bold = True
+        cfg.font_size = QApplication.font().pointSize()
+        self.highlighterSettings.append(cfg)
+
+    @Slot(object)
+    def setHighlighterSettings(self, settings: List[TextHighlighterConfig]):
+        self.highlighterSettings = settings
+        for ctrl in self.controller.values():
+            ctrl.view.setHighlighterSettings(self.highlighterSettings)
+
+    @Slot()
+    def showSerialViewerCreateDialog(self):
+        already_used_ports = list(self.controller.keys())
+        self.mainWindow.showSerialViewerCreateDialog(already_used_ports)
+
+    @Slot(str, SerialConnectionSettings)
+    def createSerialViewer(self, window_title: str, settings: SerialConnectionSettings, size: QSize = None):
+        if settings.portName in self.controller:
+            raise Exception(f"{settings.portName} exists already")
+
+        receiver = SerialDataReceiver(settings)
+        processor = SerialDataProcessor(receiver.rxQueue)
+        view = self.mainWindow.createSerialViewerWindow(window_title, size)
+        view.setHighlighterSettings(self.highlighterSettings)
+        ctrl = SerialViewerController(receiver, processor, view)
+
+        ctrl.terminated.connect(self.deleteSerialViewer)
+        self.controller[settings.portName] = ctrl
+
+        if self.mainWindow.getConnectionState():
+            ctrl.start()
+
+    @Slot()
+    def deleteSerialViewer(self, portName):
+        if portName in self.controller:
+            del self.controller[portName]
+        else:
+            raise Exception("Controller to remove does not exist in list")
+
+    @Slot()
+    def clearAll(self):
+        for ctrl in self.controller.values():
+            ctrl.view.clear()
+
+    @Slot(bool)
+    def changeConnectionState(self, state):
+        if len(self.controller.values()) > 0:
+            if state:
+                failed_to_connect = False
+
+                # try to connect all ports
+                for ctrl in self.controller.values():
+                    if not ctrl.start():
+                        failed_to_connect = True
+
+                if failed_to_connect:
+                    # cleanup if connect failed
+                    for ctrl in self.controller.values():
+                        ctrl.stop()
+                    self.mainWindow.setConnectionState(False)
+                else:
+                    self.mainWindow.setConnectionState(True)
+            else:
+                for ctrl in self.controller.values():
+                    ctrl.stop()
+                self.mainWindow.setConnectionState(False)
+
+    def loadSettings(self):
+        settings = QSettings(self.main_config_file_path, QSettings.Format.IniFormat)
+
+        settings.beginGroup("MainWindow")
+        self.mainWindow.resize(settings.value("size", QSize(800, 800)))
+        settings.endGroup()
+
+    def saveSettings(self):
+        settings = QSettings(self.main_config_file_path, QSettings.Format.IniFormat)
+
+        settings.beginGroup("MainWindow")
+        settings.setValue("size", self.mainWindow.size())
+        settings.endGroup()
+
+    def loadSerialViewerSettings(self):
+        settings = QSettings(self.main_config_file_path, QSettings.Format.IniFormat)
+
+        number_of_connections = settings.beginReadArray("connections")
+        for i in range(number_of_connections):
+            settings.setArrayIndex(i)
+
+            # check if all needed keys exist
+            if all(elem in settings.allKeys() for elem in ['serialViewer', 'view/size', 'view/title']):
+                self.createSerialViewer(settings.value("view/title"), settings.value("serialViewer"),
+                                        settings.value("view/size"))
+        settings.endArray()
+
+    @Slot()
+    def saveSerialViewerSettings(self):
+        settings = QSettings(self.main_config_file_path, QSettings.Format.IniFormat)
+
+        settings.beginWriteArray("connections")
+        settings.remove("")  # remove all existing connections
+
+        for i, ctrl in enumerate(self.controller.values()):
+            settings.setArrayIndex(i)
+            settings.setValue("serialViewer", ctrl.receiver.settings)
+            settings.setValue("view/title", ctrl.view.windowTitle())
+            settings.setValue("view/size", ctrl.view.size())
+
+        settings.endArray()
+
+    def loadHighlighterSettings(self):
+        settings = QSettings(self.highlighter_config_file_path, QSettings.Format.IniFormat)
+
+        number_of_settings = settings.beginReadArray("settings")
+        if number_of_settings > 0:
+            self.highlighterSettings = []
+
+            for i in range(number_of_settings):
+                settings.setArrayIndex(i)
+
+                # check if all needed keys exist
+                if all(elem in settings.allKeys() for elem in ['pattern', 'color_foreground', 'color_background', 'italic', 'bold']):
+                    cfg = TextHighlighterConfig()
+                    cfg.pattern = settings.value("pattern")
+                    cfg.color_foreground = settings.value("color_foreground")
+                    cfg.color_background = settings.value("color_background")
+                    cfg.italic = settings.value("italic", type=bool)
+                    cfg.bold = settings.value("bold", type=bool)
+                    cfg.font_size = settings.value("font_size", type=int)
+                    self.highlighterSettings.append(cfg)
+            settings.endArray()
+        else:
+            self.initDefaultHighlighterSettings()
+
+    @Slot()
+    def saveHighlighterSettings(self):
+        settings = QSettings(self.highlighter_config_file_path, QSettings.Format.IniFormat)
+
+        settings.beginWriteArray("settings")
+        settings.remove("")  # remove all existing settings
+
+        for i, cfg in enumerate(self.highlighterSettings):
+            settings.setArrayIndex(i)
+            settings.setValue("pattern", cfg.pattern)
+            settings.setValue("color_foreground", cfg.color_foreground)
+            settings.setValue("color_background", cfg.color_background)
+            settings.setValue("italic", cfg.italic)
+            settings.setValue("bold", cfg.bold)
+            settings.setValue("font_size", cfg.font_size)
+        settings.endArray()
+
+    @Slot()
+    def stopAllSerialViewer(self):
+        for ctrl in self.controller.values():
+            ctrl.stop()
+
+    @Slot()
+    def showHighlighterSettingsDialog(self):
+        self.mainWindow.showHighlighterSettingsDialog(copy.deepcopy(self.highlighterSettings))

multiserialviewer/application/proxyStyle.py

@@ -0,0 +1,10 @@
+from PySide6.QtWidgets import QProxyStyle, QStyle
+
+
+class ProxyStyle(QProxyStyle):
+    def subElementRect(self, element, opt, widget=None):
+        if element == QStyle.SE_ItemViewItemCheckIndicator and not opt.text:
+            rect = super().subElementRect(element, opt, widget)
+            rect.moveCenter(opt.rect.center())
+            return rect
+        return super().subElementRect(element, opt, widget)

multiserialviewer/application/serialViewerController.py

@@ -0,0 +1,50 @@
+from PySide6.QtCore import QObject, Slot, Signal
+
+from multiserialviewer.gui.serialViewerWindow import SerialViewerWindow
+from multiserialviewer.serial_data.serialDataReceiver import SerialDataReceiver
+from multiserialviewer.serial_data.serialDataProcessor import SerialDataProcessor
+
+
+class SerialViewerController(QObject):
+    terminated = Signal(str)
+
+    def __init__(self, receiver: SerialDataReceiver, processor: SerialDataProcessor, view: SerialViewerWindow):
+        super().__init__()
+
+        self.receiver = receiver
+        self.processor = processor
+        self.view = view
+
+        self.view.closed.connect(self.terminate)
+        self.processor.dataAvailable.connect(self.view.appendData)
+
+    def start(self) -> bool:
+        if self.receiver.open_port():
+            self.processor.start()
+            self.receiver.start()
+            self.show_message(f'Opened {self.receiver.settings.portName}')
+            return True
+        else:
+            self.show_error(f'Failed to open {self.receiver.settings.portName}')
+            return False
+
+    def stop(self):
+        if self.receiver.isReceiving():
+            self.receiver.stop()
+            self.receiver.close_port()
+            self.processor.stop()
+            self.show_message(f'Closed {self.receiver.settings.portName}')
+
+    def show_message(self, text):
+        self.view.appendData(f'\n[MSG: {text} :MSG]\n', True)
+
+    def show_error(self, text):
+        self.view.appendData(f'\n[ERR: {text} :ERR]\n', True)
+
+    @Slot()
+    def terminate(self):
+        # view is already closed
+        self.receiver.stop()
+        self.receiver.close_port()
+        self.processor.stop()
+        self.terminated.emit(self.receiver.settings.portName)

multiserialviewer/gui/mainWindow.py

@@ -0,0 +1,80 @@
+from PySide6.QtWidgets import QMdiArea, QMainWindow, QPushButton
+from PySide6.QtCore import QSize, Signal
+
+from typing import List
+
+from multiserialviewer.ui_files.uiFileHelper import createWidgetFromUiFile
+from multiserialviewer.serial_data.serialConnectionSettings import SerialConnectionSettings
+from multiserialviewer.gui.serialViewerWindow import SerialViewerWindow
+from multiserialviewer.gui.serialViewerCreateDialog import SerialViewerCreateDialog
+from multiserialviewer.gui.textHighlighterSettingsDialog import TextHighlighterSettingsDialog
+from multiserialviewer.text_highlighter.textHighlighter import TextHighlighterConfig
+
+
+class MainWindow(QMainWindow):
+    signal_showSerialViewerCreateDialog = Signal()
+    signal_createSerialViewer = Signal(str, SerialConnectionSettings)
+    signal_clearAll = Signal()
+    signal_connectionStateChanged = Signal(bool)
+    signal_aboutToBeClosed = Signal()
+    signal_editHighlighterSettings = Signal()
+    signal_applyHighlighterSettings = Signal(object)
+
+    def __init__(self, title: str):
+        super(MainWindow, self).__init__()
+        self.setWindowTitle(title)
+
+        widget = createWidgetFromUiFile("mainWindow.ui")
+
+        self.mdiArea = widget.findChild(QMdiArea, 'mdiArea')
+        self.pb_changeConnectionState: QPushButton = widget.findChild(QPushButton, 'pb_changeConnectionState')
+
+        self.setCentralWidget(widget)
+        self.setConnectionState(False)
+
+        # connections
+        widget.pb_create.clicked.connect(self.signal_showSerialViewerCreateDialog)
+        widget.pb_clear.clicked.connect(self.signal_clearAll)
+        widget.pb_changeConnectionState.clicked.connect(self.signal_connectionStateChanged)
+        widget.pb_highlighter.clicked.connect(self.signal_editHighlighterSettings)
+
+    def showSerialViewerCreateDialog(self, disabled_ports: list):
+        dialog = SerialViewerCreateDialog(self)
+        dialog.disablePorts(disabled_ports)
+        if dialog.exec():
+            port_name = dialog.getPortName()
+            if len(port_name) > 0:
+                settings = SerialConnectionSettings(port_name)
+                settings.baudrate = dialog.getBaudrate()
+                settings.bytesize = dialog.getDataBits()
+                settings.parity = dialog.getParity()
+                settings.stopbits = dialog.getStopBits()
+
+                self.signal_createSerialViewer.emit(dialog.getName(), settings)
+
+    def createSerialViewerWindow(self, viewTitle: str, size: QSize = None):
+        view = SerialViewerWindow(viewTitle)
+        if size:
+            view.resize(size)
+        self.mdiArea.addSubWindow(view)
+        view.show()
+        return view
+
+    def showHighlighterSettingsDialog(self, settings: List[TextHighlighterConfig]):
+        dialog = TextHighlighterSettingsDialog(self, settings)
+        if dialog.exec():
+            self.signal_applyHighlighterSettings.emit(dialog.table_model.settings)
+
+    def getConnectionState(self):
+        return self.pb_changeConnectionState.isChecked()
+
+    def setConnectionState(self, state):
+        self.pb_changeConnectionState.setChecked(state)
+        if state:
+            self.pb_changeConnectionState.setText('Stop')
+        else:
+            self.pb_changeConnectionState.setText('Start')
+
+    def closeEvent(self, event):
+        self.signal_aboutToBeClosed.emit()
+        event.accept()

multiserialviewer/gui/serialViewerCreateDialog.py

@@ -0,0 +1,96 @@
+from PySide6.QtWidgets import QDialog, QVBoxLayout, QDialogButtonBox
+from PySide6.QtCore import Slot
+import serial.tools.list_ports
+import serial
+
+from multiserialviewer.ui_files.uiFileHelper import createWidgetFromUiFile
+
+
+class SerialViewerCreateDialog(QDialog):
+    def __init__(self, parent):
+        super().__init__(parent)
+
+        self.setWindowTitle("Create SerialViewer")
+        self.disabled_port_names = []
+
+        self.connectWidget = createWidgetFromUiFile("createSerialViewerDialog.ui")
+
+        self.refreshListOfSerialPorts()
+        self.populateBaudRateCombobox()
+        self.populateDataBitsCombobox()
+        self.populateParityCombobox()
+        self.populateStopBitsCombobox()
+
+        self.connectWidget.pb_refresh.clicked.connect(self.refreshListOfSerialPorts)
+        self.connectWidget.buttonBox.accepted.connect(self.accept)
+        self.connectWidget.buttonBox.rejected.connect(self.reject)
+
+        QVBoxLayout(self).addWidget(self.connectWidget)
+
+    def disablePorts(self, disabled_port_names: list):
+        self.disabled_port_names = disabled_port_names
+        self.refreshListOfSerialPorts()
+
+    @Slot()
+    def refreshListOfSerialPorts(self):
+        port_name_list = [p.device for p in serial.tools.list_ports.comports() if
+                          p.device not in self.disabled_port_names]
+        self.connectWidget.cb_portName.clear()
+        self.connectWidget.cb_portName.addItems(port_name_list)
+
+        ok_button_enabled_state = len(port_name_list) > 0
+        self.connectWidget.buttonBox.button(QDialogButtonBox.Ok).setEnabled(ok_button_enabled_state)
+
+    def populateBaudRateCombobox(self):
+        baudrates = ['9600', '38400', '115200', '256000', '1000000']
+        self.connectWidget.cb_baudrate.clear()
+        self.connectWidget.cb_baudrate.addItems(baudrates)
+        self.connectWidget.cb_baudrate.setCurrentIndex(4)
+
+    def populateDataBitsCombobox(self):
+        self.connectWidget.cb_dataSize.clear()
+        self.connectWidget.cb_dataSize.addItem(str(serial.FIVEBITS), userData=serial.FIVEBITS)
+        self.connectWidget.cb_dataSize.addItem(str(serial.SIXBITS), userData=serial.SIXBITS)
+        self.connectWidget.cb_dataSize.addItem(str(serial.SEVENBITS), userData=serial.SEVENBITS)
+        self.connectWidget.cb_dataSize.addItem(str(serial.EIGHTBITS), userData=serial.EIGHTBITS)
+        self.connectWidget.cb_dataSize.setCurrentIndex(3)
+
+    def populateParityCombobox(self):
+        self.connectWidget.cb_parity.clear()
+        self.connectWidget.cb_parity.addItem(serial.PARITY_NAMES[serial.PARITY_NONE], userData=serial.PARITY_NONE)
+        self.connectWidget.cb_parity.addItem(serial.PARITY_NAMES[serial.PARITY_EVEN], userData=serial.PARITY_EVEN)
+        self.connectWidget.cb_parity.addItem(serial.PARITY_NAMES[serial.PARITY_ODD], userData=serial.PARITY_ODD)
+        self.connectWidget.cb_parity.addItem(serial.PARITY_NAMES[serial.PARITY_MARK], userData=serial.PARITY_MARK)
+        self.connectWidget.cb_parity.addItem(serial.PARITY_NAMES[serial.PARITY_SPACE], userData=serial.PARITY_SPACE)
+        self.connectWidget.cb_parity.setCurrentIndex(0)
+
+    def populateStopBitsCombobox(self):
+        self.connectWidget.cb_stopBits.clear()
+        self.connectWidget.cb_stopBits.addItem(str(serial.STOPBITS_ONE), userData=serial.STOPBITS_ONE)
+        self.connectWidget.cb_stopBits.addItem(str(serial.STOPBITS_ONE_POINT_FIVE),
+                                               userData=serial.STOPBITS_ONE_POINT_FIVE)
+        self.connectWidget.cb_stopBits.addItem(str(serial.STOPBITS_TWO), userData=serial.STOPBITS_TWO)
+        self.connectWidget.cb_stopBits.setCurrentIndex(0)
+
+    def getName(self):
+        name = self.connectWidget.ed_name.text()
+        if name == '':
+            name = self.getPortName()
+        elif self.getPortName() not in name:
+            name = '{} ({})'.format(name, self.getPortName())
+        return name
+
+    def getPortName(self):
+        return self.connectWidget.cb_portName.currentText()
+
+    def getBaudrate(self):
+        return self.connectWidget.cb_baudrate.currentText()
+
+    def getDataBits(self):
+        return self.connectWidget.cb_dataSize.currentData()
+
+    def getParity(self):
+        return self.connectWidget.cb_parity.currentData()
+
+    def getStopBits(self):
+        return self.connectWidget.cb_stopBits.currentData()

multiserialviewer/gui/serialViewerWindow.py

@@ -0,0 +1,67 @@
+from PySide6.QtCore import Qt, Slot, Signal
+from PySide6.QtGui import QTextCursor, QClipboard
+from PySide6.QtWidgets import QApplication, QMdiSubWindow, QTextEdit, QPushButton, QCheckBox
+from typing import List
+from multiserialviewer.text_highlighter.textHighlighter import TextHighlighter, TextHighlighterConfig
+from multiserialviewer.ui_files.uiFileHelper import createWidgetFromUiFile
+
+
+class SerialViewerWindow(QMdiSubWindow):
+    closed = Signal()
+
+    def __init__(self, window_title):
+        super().__init__()
+
+        widget = createWidgetFromUiFile("serialViewerWindow.ui")
+
+        self.setWidget(widget)
+        self.setWindowTitle(window_title)
+        self.setAttribute(Qt.WA_DeleteOnClose)
+
+        self.textEdit: QTextEdit = widget.findChild(QTextEdit, 'textEdit')
+
+        self.highlighter = TextHighlighter()
+        self.highlighter.setDocument(self.textEdit.document())
+
+        pb_clear: QPushButton = widget.findChild(QPushButton, 'pb_clear')
+        pb_clear.pressed.connect(self.clear)
+
+        pb_copy: QPushButton = widget.findChild(QPushButton, 'pb_copy')
+        pb_copy.pressed.connect(self.copy)
+
+        self.checkBox_enabled: QCheckBox = self.widget().findChild(QCheckBox, 'checkBox_enabled')
+
+    def closeEvent(self, event):
+        # is not called when mainwindow is closed
+        event.accept()
+        self.closed.emit()
+
+    @Slot()
+    def clear(self):
+        self.textEdit.clear()
+
+    def setHighlighterSettings(self, settings: List[TextHighlighterConfig]):
+        self.highlighter.setSettings(settings)
+        self.highlighter.rehighlight()
+
+    @Slot()
+    def copy(self):
+        clipboard: QClipboard = QApplication.clipboard()
+        cursor = self.textEdit.textCursor()
+
+        if cursor.selection().isEmpty():
+            text = self.textEdit.toPlainText()
+        else:
+            # copy selected text
+            text = cursor.selection().toPlainText()
+
+        if len(text) > 0:
+            clipboard.setText(text)
+
+    @Slot()
+    def appendData(self, data, force=False):
+        if self.checkBox_enabled.isChecked() or force:
+            self.textEdit.moveCursor(QTextCursor.End)
+            self.textEdit.insertPlainText(data)
+            self.textEdit.ensureCursorVisible()
+

multiserialviewer/gui/textHighlighterSettingsDialog.py

@@ -0,0 +1,46 @@
+from PySide6.QtWidgets import QDialog, QVBoxLayout, QHeaderView
+from typing import List
+
+from multiserialviewer.ui_files.uiFileHelper import createWidgetFromUiFile
+from multiserialviewer.text_highlighter.textHighlighterConfig import TextHighlighterConfig
+from multiserialviewer.text_highlighter.textHighlighterTableModel import TextHighlighterTableModel
+from multiserialviewer.text_highlighter.colorSelectorItemDelegate import ColorSelectorItemDelegate
+
+
+class TextHighlighterSettingsDialog(QDialog):
+    def __init__(self, parent, settings: List[TextHighlighterConfig]):
+        super().__init__(parent)
+
+        self.setWindowTitle("Text Highlighter Settings")
+        self.widget = createWidgetFromUiFile("textHighlighterSettingsDialog.ui")
+
+        self.table_model = TextHighlighterTableModel(settings)
+        self.widget.tableView.setModel(self.table_model)
+        self.widget.tableView.setItemDelegateForColumn(1, ColorSelectorItemDelegate(self.widget.tableView))
+        self.widget.tableView.setItemDelegateForColumn(2, ColorSelectorItemDelegate(self.widget.tableView))
+
+        # QTableView Headers
+        self.horizontal_header = self.widget.tableView.horizontalHeader()
+        self.vertical_header = self.widget.tableView.verticalHeader()
+
+        # size
+        self.horizontal_header.setSectionResizeMode(QHeaderView.Stretch)
+        self.horizontal_header.setSectionResizeMode(3, QHeaderView.ResizeToContents)
+        self.horizontal_header.setSectionResizeMode(4, QHeaderView.ResizeToContents)
+
+        # buttons
+        self.widget.buttonBox.accepted.connect(self.accept)
+        self.widget.buttonBox.rejected.connect(self.reject)
+        self.widget.pb_add.clicked.connect(self.addSetting)
+        self.widget.pb_delete.clicked.connect(self.deleteSetting)
+
+        QVBoxLayout(self).addWidget(self.widget)
+
+    def addSetting(self):
+        self.table_model.insertRows(self.table_model.rowCount(), 1)
+
+    def deleteSetting(self):
+        selected_model_indices = [modelIndex.row() for modelIndex in self.widget.tableView.selectionModel().selectedRows()]
+
+        for index in sorted(selected_model_indices, reverse=True):
+            self.table_model.removeRows(index, 1)

multiserialviewer/serial_data/serialConnectionSettings.py

@@ -0,0 +1,11 @@
+import serial
+
+
+class SerialConnectionSettings:
+    def __init__(self, port_name: str):
+        self.portName = port_name
+        self.baudrate = 1000000
+        self.bytesize = serial.EIGHTBITS
+        self.parity = serial.PARITY_NONE
+        self.stopbits = serial.STOPBITS_ONE
+        self.timeout = 0.5

multiserialviewer/serial_data/serialDataProcessor.py

@@ -0,0 +1,51 @@
+import time
+from threading import Thread, Event
+from queue import Empty
+from PySide6.QtCore import Signal, QObject
+
+
+class SerialDataProcessor(QObject):
+    dataAvailable = Signal(str)
+
+    def __init__(self, raw_data_queue):
+        super(SerialDataProcessor, self).__init__()
+        self.lastEmitTimestamp = self.getTimestamp()
+        self.terminateEvent = Event()
+        self.rawDataQueue = raw_data_queue
+        self.thread = None
+
+    def start(self):
+        if self.thread is None:
+            self.thread = Thread(target=self.processData, args=(self.rawDataQueue, self.terminateEvent))
+            self.thread.start()
+
+    def stop(self):
+        if self.thread and self.thread.is_alive():
+            self.terminateEvent.set()
+            self.thread.join()
+            self.thread = None
+            self.terminateEvent.clear()
+
+    def getTimestamp(self):
+        return int(round(time.time() * 1000))
+
+    def timeDiffSinceLastEmit(self):
+        return self.getTimestamp() - self.lastEmitTimestamp
+
+    def processData(self, queue, terminate_event):
+        data = bytearray()
+
+        while not terminate_event.is_set():
+            try:
+                rx_bytes = queue.get(timeout=0.2)
+                data.extend(rx_bytes)
+                # queue.task_done()
+            except Empty:
+                pass
+            finally:
+                if len(data) > 0:
+                    try:
+                        self.dataAvailable.emit(data.decode("ascii"))
+                    except:
+                        pass
+                    data = bytearray()