Über... hinzugefügt, Icon hinzugefügt

.gitignore

@@ -1 +1,2 @@
-build/
+build/
+uartscope-git/

CMakeLists.txt

@@ -23,6 +23,8 @@ set(SOURCES
     src/tagwidget.cpp
     src/tagpanel.cpp
     src/connectdialog.cpp
+    src/v4l2worker.cpp
+    src/videowidget.cpp
 )
 
 set(HEADERS
@@ -33,9 +35,12 @@ set(HEADERS
     include/tagwidget.h
     include/tagpanel.h
     include/connectdialog.h
+    include/v4l2worker.h
+    include/videowidget.h
 )
 
-add_executable(uartscope ${SOURCES} ${HEADERS})
+qt6_add_resources(RESOURCES resources.qrc)
+add_executable(uartscope ${SOURCES} ${HEADERS} ${RESOURCES})
 
 target_include_directories(uartscope PRIVATE include)
 
@@ -46,6 +51,10 @@ target_link_libraries(uartscope PRIVATE
     Qt6::SerialPort
 )
 
+# V4L2 uses Linux kernel headers directly (linux/videodev2.h)
+# These are part of linux-api-headers / linux-libc-dev on all major distros.
+# No additional library linkage needed.
+
 # Installation
 install(TARGETS uartscope DESTINATION bin)
 
@@ -56,3 +65,6 @@ configure_file(
     @ONLY
 )
 install(FILES ${CMAKE_BINARY_DIR}/uartscope.desktop DESTINATION share/applications)
+install(FILES ${CMAKE_SOURCE_DIR}/UartscopeLogo.png
+        DESTINATION share/icons/hicolor/512x512/apps
+        RENAME uartscope.png)

README.md

@@ -1,6 +1,6 @@
 # UARTScope
 
-Ein moderner UART-Monitor für Linux mit Qt6-Oberfläche. Gebaut als Ersatz für minicom mit deutlich mehr Komfort – besonders nützlich bei der Entwicklung von Baremetal-Projekten wie [Chica](https://github.com/).
+Ein moderner UART-Monitor für Linux mit Qt6-Oberfläche. Gebaut als vollwertiger Ersatz für minicom – besonders nützlich bei der Entwicklung von Baremetal-Projekten wie [Chica](https://git.projekt-hirnfrei.de/diabolus/chica) (Amiga-Hardware-Nachbildung auf dem Raspberry Pi).
 
 ---
 
@@ -8,35 +8,45 @@ Ein moderner UART-Monitor für Linux mit Qt6-Oberfläche. Gebaut als Ersatz für
 
 | Feature | Beschreibung |
 |---|---|
-| **Unbegrenzter Verlauf** | QPlainTextEdit mit unlimitierter Zeilenzahl – keine Daten gehen verloren |
+| **Unbegrenzter Verlauf** | Kein Zeilenlimit – keine Daten gehen verloren, egal wie viel der Pi sendet |
-| **Horizontal + vertikal scrollen** | Kein Zeilenumbruch, voller H-Scrollbalken |
+| **Timestamps** | Jede Zeile im Raw-View bekommt automatisch einen `hh:mm:ss.zzz`-Timestamp |
-| **Live-Logging** | Jede empfangene Zeile wird mit Zeitstempel in eine Datei geschrieben |
+| **H + V Scrolling** | Kein Zeilenumbruch, voller horizontaler Scrollbalken |
-| **Tag-Monitor** | Zeilen mit `[TAG]` werden abgefangen und in eigenen Panels angezeigt |
+| **Live-Logging** | Alle empfangenen Zeilen werden mit Timestamp in eine Datei geschrieben |
-| **Tabellenansicht** | CSV-formatierte UART-Zeilen werden in einer sortierbaren Tabelle dargestellt |
+| **Tag-Monitor** | Zeilen mit `[TAG]` werden in eigenen Panels angezeigt und aktualisiert |
+| **Tag-Filter** | Tags können aus dem Raw-View ausgeblendet werden (nur im Tag-Monitor sichtbar) |
+| **Tabellenansicht** | CSV-formatierte UART-Zeilen werden in einer Tabelle dargestellt |
 | **Suche** | Inkrementelle Volltextsuche im Raw-View |
-| **Dunkles Theme** | Fusion Dark – passt gut zur Terminal-Ästhetik |
+| **Auto-Reconnect** | Bei Verbindungsabbruch wird automatisch neu verbunden (Intervall einstellbar) |
+| **ANSI Clear-Screen** | `\033[2J\033[H` aus der Firmware leert alle Views gleichzeitig |
+| **Copy-Buttons** | Raw-View und jedes Tag-Panel haben einen „📋 Copy"-Button |
+| **V4L2 Live Video** | HDMI-Grabber direkt eingebunden – Live-Vorschau unter dem Tag-Monitor |
+| **Screenshot** | Aktuellen Frame des HDMI-Grabbers als PNG/JPG speichern |
+| **Format-Referenz** | Eingebauter Guide (mit Kopieren-Button) für KI-kompatible UART-Formatierung |
+| **Fensterlayout** | Fenstergröße, Position und alle Splitter-Positionen werden beim Beenden gespeichert |
 
 ---
 
 ## Voraussetzungen
 
 ```bash
+# Arch (empfohlen)
+sudo pacman -S cmake qt6-base qt6-serialport
+
 # Ubuntu / Debian
 sudo apt install cmake qt6-base-dev qt6-serialport-dev libqt6serialport6-dev
 
-# Arch
-sudo pacman -S cmake qt6-base qt6-serialport
-
 # Fedora
 sudo dnf install cmake qt6-qtbase-devel qt6-qtserialport-devel
 ```
 
+V4L2 benötigt keine zusätzliche Library – `linux/videodev2.h` ist Teil der Standard-Kernel-Header.
+
 ---
 
 ## Build
 
 ```bash
-git clone <repo>
+git clone https://git.projekt-hirnfrei.de/diabolus/uartscope.git
 cd uartscope
 cmake -B build -DCMAKE_BUILD_TYPE=Release
 cmake --build build -j$(nproc)
@@ -50,59 +60,85 @@ sudo cmake --install build
 
 ---
 
+## Berechtigungen
+
+```bash
+# UART-Port
+sudo usermod -aG dialout $USER
+
+# HDMI-Grabber / V4L2
+sudo usermod -aG video $USER
+
+# Einmal ausloggen / neu einloggen
+```
+
+Grabber testen:
+```bash
+v4l2-ctl --list-devices                      # alle /dev/video* Geräte
+v4l2-ctl -d /dev/video0 --list-formats-ext  # unterstützte Formate & Auflösungen
+```
+
+---
+
 ## UART-Ausgabe formatieren
 
-### Tag-Monitor (`[TAG]`)
+### Raw-View (immer aktiv)
 
-Der Tag-Monitor fängt Zeilen ab, die ein Tag der Form `[TAGNAME]` enthalten.  
+Jede UART-Zeile erscheint im Raw-View mit Timestamp. Keine besondere Formatierung nötig.
-Das Tag erscheint weiterhin im Raw-View (eingefärbt), wird aber **zusätzlich** im Tag-Panel aktualisiert.
 
-**Watchdog-Beispiel** – dein Watchdog-Handler schickt:
+**Screen leeren** – von der Firmware aus alle Views gleichzeitig leeren:
-```
-[WDG] uptime=12345 free_heap=43210 load=0.82
-```
-→ UARTScope erstellt automatisch ein Panel `[WDG]` mit einer Tabelle:
-
-| Key | Value |
-|---|---|
-| uptime | 12345 |
-| free_heap | 43210 |
-| load | 0.82 |
-
-Jedes Update blinkt kurz grün auf – du siehst sofort, dass neue Daten angekommen sind.
-
-**Mehrere Tags gleichzeitig:**
 ```c
-// In deinem Baremetal-Code:
+uart_printf("\033[2J\033[H");
-uart_printf("[WDG] uptime=%lu free=%lu\n", uptime, heap_free);
-uart_printf("[VIDEO] line=%d hblank=%d vblank=%d\n", line, hb, vb);
-uart_printf("[AUDIO] buf=%d underruns=%d\n", audio_buf, underruns);
 ```
-Für jeden einzigartigen Tag wird automatisch ein eigenes Panel erstellt.
+
+### Tag-Monitor
+
+Zeilen mit `[TAGNAME]` werden im Tag-Monitor-Panel angezeigt **und** im Raw-View hervorgehoben (cyan). Über „Tag filter…" in der Toolbar können Tags vollständig aus dem Raw-View ausgeblendet werden, sodass sie nur noch im Tag-Monitor erscheinen.
+
+**Format:** `[TAGNAME] key1=value1 key2=value2 ...`
+
+- Tag-Name: Buchstaben, Ziffern, Underscore – z.B. `WDG`, `VIDEO`, `I2C_BUS`
+- Key=Value-Paare: Leerzeichen-getrennt, Werte ohne Leerzeichen
+- Ohne Key=Value-Paare wird der rohe String angezeigt
+
+**Beispiele:**
+```c
+uart_printf("[WDG] uptime=%lu free_heap=%lu temp=%d\n",
+            HAL_GetTick(), xPortGetFreeHeapSize(), core_temp);
+
+uart_printf("[VIDEO] line=%d hblank=%d vblank=%d copper=%d\n",
+            scanline, hblank_ticks, vblank_ticks, copper_dma);
+
+uart_printf("[AUDIO] ch=%d buf=%d underruns=%lu\n",
+            active_channels, buffer_fill, underruns);
+```
+
+Jeder einzigartige Tag bekommt automatisch ein eigenes Panel. Panels aktualisieren sich in-place – kein Scrollen nötig.
 
 ### Tabellenansicht
 
-Die Tabellenansicht erwartet CSV-Zeilen. Optionale Header-Zeile mit `#`:
+Optionale Header-Zeile mit `#`, dann CSV-Datenzeilen:
 
 ```
 #time_ms,temperature,voltage,current
 1000,23.5,3.30,0.42
 2000,23.7,3.31,0.41
-3000,24.1,3.29,0.43
 ```
 
-Delimiter ist per Dropdown umschaltbar (`,` `;` `\t` `|` `Space`).
+Delimiter per Dropdown umschaltbar: `,` `;` `\t` `|` `Space`
 
 ---
 
-## Serielle Ports – Berechtigungen
+## Einstellungen
 
-Auf den meisten Linux-Distros muss dein User in der Gruppe `dialout` sein:
+Beim Beenden werden folgende Einstellungen automatisch gespeichert und beim nächsten Start wiederhergestellt:
 
-```bash
+- Fenstergröße und -position
-sudo usermod -aG dialout $USER
+- Splitter-Positionen (Haupt-Splitter und Tag/Video-Splitter)
-# Einmal ausloggen / neu einloggen
+- Auto-Reconnect ein/aus und Intervall
-```
+- Tag-Filter (ausgeblendete Tags)
+
+Gespeichert unter `~/.config/ChicaDev/UARTScope.conf` (via `QSettings`).
 
 ---
 
@@ -111,14 +147,18 @@ sudo usermod -aG dialout $USER
 ```
 uartscope/
 ├── CMakeLists.txt
+├── README.md
+├── uartscope.desktop.in
 ├── include/
-│   ├── mainwindow.h
+│   ├── mainwindow.h       ← Hauptfenster, koordiniert alle Komponenten
-│   ├── serialworker.h     ← UART-Empfang im eigenen Thread
+│   ├── serialworker.h     ← UART-Empfang im eigenen QThread, Auto-Reconnect
-│   ├── rawview.h          ← Unbegrenzter scrollbarer Log
+│   ├── rawview.h          ← Unbegrenzter Log mit Timestamps, Suche, Copy
-│   ├── tableview.h        ← CSV → QTableWidget
+│   ├── tableview.h        ← CSV-Parser → QTableWidget
 │   ├── tagwidget.h        ← Container für Tag-Panels
-│   ├── tagpanel.h         ← Ein Panel pro [TAG]
+│   ├── tagpanel.h         ← Ein Panel pro [TAG], Key=Value-Tabelle, Copy
-│   └── connectdialog.h    ← Port-Konfiguration
+│   ├── connectdialog.h    ← Port-Konfiguration (Port, Baud, Log-Datei)
+│   ├── v4l2worker.h       ← V4L2-Capture in std::thread, MJPEG/YUYV/NV12
+│   └── videowidget.h      ← Live-Vorschau, Freeze, Screenshot
 └── src/
     ├── main.cpp
     ├── mainwindow.cpp
@@ -127,15 +167,17 @@ uartscope/
     ├── tableview.cpp
     ├── tagwidget.cpp
     ├── tagpanel.cpp
-    └── connectdialog.cpp
+    ├── connectdialog.cpp
+    ├── v4l2worker.cpp
+    └── videowidget.cpp
 ```
 
 ---
 
 ## Erweiterungsideen
 
-- **Protokoll-Filter**: Zeilen anhand von Regex ein-/ausblenden
+- **Plot-Widget**: numerische Tag-Werte live als Graph darstellen (Qt Charts)
-- **Plot-Widget**: numerische Werte aus Tags live als Graph darstellen (Qt Charts)
+- **UART senden**: TX-Eingabezeile für bidirektionale Kommunikation
-- **UART senden**: TX-Eingabezeile hinzufügen für bidirektionale Kommunikation
-- **Session-Replay**: gespeicherte Log-Dateien wieder abspielen
 - **Hex-View**: rohe Bytes als Hex-Dump anzeigen
+- **Session-Replay**: gespeicherte Log-Dateien abspielen
+- **Regex-Filter**: Zeilen im Raw-View per regulärem Ausdruck ein-/ausblenden

include/mainwindow.h

@@ -1,5 +1,8 @@
 #pragma once
 #include <QMainWindow>
+#include <QCloseEvent>
+#include <QSettings>
+#include <QSplitter>
 #include <QThread>
 #include <QTabWidget>
 #include <QSplitter>
@@ -14,7 +17,9 @@
 #include "rawview.h"
 #include "tableview.h"
 #include "tagwidget.h"
+#include "videowidget.h"
 #include "connectdialog.h"
+#include <QSet>
 
 class MainWindow : public QMainWindow
 {
@@ -35,21 +40,30 @@ private slots:
     void onNewLine(const QString &line);
     void onTagDetected(const QString &tag, const QString &value);
     void showFormatReference();
+    void configureTagFilter();
+    void showAbout();
+
+protected:
+    void closeEvent(QCloseEvent *event) override;
 
 private:
     void setupUi();
     void setupToolBar();
     void setupStatusBar();
     void clearAllViews();
+    void doShutdown();
+    void saveSettings();
+    void restoreSettings();
 
     // Worker & thread
     QThread      *m_thread = nullptr;
     SerialWorker *m_worker = nullptr;
 
     // Views
-    RawView    *m_rawView   = nullptr;
+    RawView     *m_rawView    = nullptr;
-    TableView  *m_tableView = nullptr;
+    TableView   *m_tableView  = nullptr;
-    TagWidget  *m_tagWidget = nullptr;
+    TagWidget   *m_tagWidget  = nullptr;
+    VideoWidget *m_videoWidget= nullptr;
 
     // Status bar widgets
     QLabel *m_portLabel       = nullptr;
@@ -64,5 +78,11 @@ private:
     QAction *m_connectAction    = nullptr;
     QAction *m_disconnectAction = nullptr;
 
-    SerialConfig m_lastConfig;
+    // Splitters (saved/restored via QSettings)
+    QSplitter       *m_mainSplitter  = nullptr;
+    QSplitter       *m_rightSplitter = nullptr;
+
+    SerialConfig    m_lastConfig;
+    QSet<QString>   m_suppressedTags;   // tags hidden from Raw view
+    bool            m_shutdownDone = false;
 };

include/rawview.h

@@ -8,13 +8,13 @@
 #include <QCheckBox>
 #include <QLabel>
 #include <QSpinBox>
+#include <QRegularExpression>
 
 // RawView shows the raw UART output in a QPlainTextEdit with:
-//  - Configurable maximum line count (default: unlimited / very large)
+//  - Timestamp prefix on every line (hh:mm:ss.zzz)
-//  - Auto-scroll that pauses when the user scrolls up
+//  - Configurable tag suppression (lines whose tag is in the filter set are hidden)
-//  - Horizontal scroll (word wrap off)
+//  - Unlimited history, H+V scrolling, incremental search
-//  - Incremental text search
+//  - Copy-to-clipboard and Clear buttons
-//  - Clear button
 class RawView : public QWidget
 {
     Q_OBJECT
@@ -23,13 +23,15 @@ public:
     explicit RawView(QWidget *parent = nullptr);
 
 public slots:
-    void appendLine(const QString &line);
+    // suppressedTags: set of uppercase tag names whose lines should NOT appear here
+    void appendLine(const QString &line, const QSet<QString> &suppressedTags = {});
     void clear();
 
 private slots:
     void onSearch(const QString &text);
     void onScrollValueChanged(int value);
     void onAutoScrollToggled(bool enabled);
+    void copyToClipboard();
 
 private:
     void setupUi();
@@ -38,8 +40,11 @@ private:
     QPlainTextEdit *m_textEdit     = nullptr;
     QLineEdit      *m_searchEdit   = nullptr;
     QPushButton    *m_clearBtn     = nullptr;
+    QPushButton    *m_copyBtn      = nullptr;
     QCheckBox      *m_autoScrollCb = nullptr;
     QLabel         *m_lineCountLbl = nullptr;
     bool            m_autoScroll   = true;
     int             m_lineCount    = 0;
+
+    static const QRegularExpression s_tagRe;
 };

include/tagpanel.h

@@ -1,17 +1,16 @@
 #pragma once
-#include <QWidget>
 #include <QGroupBox>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
-#include <QDateTime>
+#include <QPushButton>
-#include <QList>
-#include <QPair>
 #include <QTableWidget>
+#include <QStringList>
 
-// TagPanel displays the most recent data associated with a single tag (e.g. [WDG]).
+// TagPanel displays the most recent data for a single tag (e.g. [WDG]).
-// Values are parsed as key=value pairs, or shown as a raw string if no '=' is found.
+// Key=value pairs are shown in a table that updates in-place.
-// Example input line:  [WDG] uptime=1234 temp=42.1 load=0.8
+// A "Copy" button copies the current values to the clipboard.
+// No timestamp is shown here – timestamps belong in the Raw view.
 class TagPanel : public QGroupBox
 {
     Q_OBJECT
@@ -24,14 +23,16 @@ public:
 public slots:
     void update(const QString &value);
 
+private slots:
+    void copyToClipboard();
+
 private:
     void parseKeyValue(const QString &value);
     void showRaw(const QString &value);
     void ensureRow(const QString &key);
 
     QString       m_tag;
-    QTableWidget *m_table      = nullptr;
+    QTableWidget *m_table    = nullptr;
-    QLabel       *m_rawLabel   = nullptr;
+    QLabel       *m_rawLabel = nullptr;
-    QLabel       *m_timestampLabel = nullptr;
+    QStringList   m_keys;
-    QStringList   m_keys;   // ordered list for row lookup
 };

include/v4l2worker.h

@@ -0,0 +1,49 @@
+#pragma once
+#include <QObject>
+#include <QImage>
+#include <QString>
+#include <atomic>
+#include <thread>
+
+class V4l2Worker : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit V4l2Worker(QObject *parent = nullptr);
+    ~V4l2Worker();
+
+public slots:
+    void startCapture(const QString &device, int width = 1920, int height = 1080);
+    void stopCapture();
+
+signals:
+    void newFrame(const QImage &frame);
+    void captureStarted(const QString &device, int width, int height, const QString &format);
+    void captureStopped();
+    void errorOccurred(const QString &message);
+
+private:
+    void stop();           // joins m_captureThread, closes device – safe from any thread
+    void captureLoop();    // runs inside m_captureThread
+    bool openDevice(const QString &device, int width, int height);
+    void closeDevice();
+    bool initMmap();
+    void freeMmap();
+    QImage convertToImage(const void *data, size_t size, int width, int height);
+    QImage yuyv2Rgb(const uchar *src, int width, int height);
+    QImage nv122Rgb(const uchar *src, int width, int height);
+
+    int           m_fd       = -1;
+    int           m_width    = 1920;
+    int           m_height   = 1080;
+    uint32_t      m_pixFmt   = 0;
+
+    static constexpr int MMAP_BUFFERS = 4;
+    struct MmapBuffer { void *start = nullptr; size_t length = 0; };
+    MmapBuffer    m_buffers[MMAP_BUFFERS];
+    int           m_nBuffers = 0;
+
+    std::atomic<bool> m_running{false};
+    std::thread       m_captureThread;   // dedicated capture thread – not the Qt event thread
+};

include/videowidget.h

@@ -0,0 +1,71 @@
+#pragma once
+#include <QWidget>
+#include <QImage>
+#include <QLabel>
+#include <QPushButton>
+#include <QComboBox>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QThread>
+#include <QTimer>
+
+#include "v4l2worker.h"
+
+// VideoWidget shows a live preview of a V4L2 capture device.
+// It lives in the right-side panel, below the Tag Monitor.
+// Features:
+//   - Device selector (auto-enumerates /dev/video*)
+//   - Start / Stop capture
+//   - Freeze-frame toggle
+//   - Screenshot (saves current frame as PNG/JPG)
+//   - Frame is scaled to fit the widget while keeping aspect ratio
+class VideoWidget : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit VideoWidget(QWidget *parent = nullptr);
+    ~VideoWidget();
+
+public:
+    // Called by MainWindow::closeEvent to guarantee orderly shutdown before
+    // widget destruction. Safe to call multiple times.
+    void shutdown();
+
+public slots:
+    void onNewFrame(const QImage &frame);
+
+private slots:
+    void onStartStop();
+    void onFreeze(bool frozen);
+    void onScreenshot();
+    void refreshDeviceList();
+
+protected:
+    void paintEvent(QPaintEvent *event) override;
+    void resizeEvent(QResizeEvent *event) override;
+
+private:
+    void setupUi();
+    void startCapture();
+    void stopCapture();
+    void updateScaled();
+
+    // Worker
+    QThread     *m_thread = nullptr;
+    V4l2Worker  *m_worker = nullptr;
+
+    // Current frame
+    QImage  m_frame;
+    QImage  m_scaled;
+    bool    m_frozen       = false;
+    bool    m_running      = false;
+    bool    m_shutdownDone = false;
+
+    // UI
+    QComboBox   *m_deviceCombo  = nullptr;
+    QPushButton *m_startBtn     = nullptr;
+    QPushButton *m_freezeBtn    = nullptr;
+    QPushButton *m_screenshotBtn= nullptr;
+    QLabel      *m_infoLabel    = nullptr;
+};

resources.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/icons">
+        <file>UartscopeLogo.png</file>
+    </qresource>
+</RCC>

src/main.cpp

@@ -29,6 +29,10 @@ int main(int argc, char *argv[])
     darkPalette.setColor(QPalette::HighlightedText, Qt::white);
     app.setPalette(darkPalette);
 
+    // Set application icon (embedded via Qt resource)
+    const QIcon appIcon(":/icons/UartscopeLogo.png");
+    app.setWindowIcon(appIcon);
+
     MainWindow w;
     w.show();
     return app.exec();

src/mainwindow.cpp

@@ -1,4 +1,5 @@
 #include "mainwindow.h"
+#include <QSettings>
 #include <QApplication>
 #include <QClipboard>
 #include <QDialog>
@@ -23,6 +24,7 @@ MainWindow::MainWindow(QWidget *parent)
     setupUi();
     setupToolBar();
     setupStatusBar();
+    restoreSettings();
 
     // ── Worker thread ─────────────────────────────────────────────────────────
     m_thread = new QThread(this);
@@ -44,16 +46,48 @@ MainWindow::MainWindow(QWidget *parent)
 
 MainWindow::~MainWindow()
 {
-    QMetaObject::invokeMethod(m_worker, "closePort", Qt::BlockingQueuedConnection);
+    // All real cleanup happens in closeEvent(). The destructor only runs if
-    m_thread->quit();
+    // the window was destroyed without a close event (e.g. programmatically),
-    m_thread->wait(3000);
+    // so we guard against double-cleanup with m_shutdownDone.
+    doShutdown();
+}
+
+void MainWindow::closeEvent(QCloseEvent *event)
+{
+    doShutdown();
+    event->accept();
+}
+
+void MainWindow::doShutdown()
+{
+    if (m_shutdownDone)
+        return;
+    m_shutdownDone = true;
+
+    saveSettings();
+
+    // 1. Stop V4L2 capture first (joins the internal std::thread)
+    if (m_videoWidget)
+        m_videoWidget->shutdown();
+
+    // 2. Stop UART serial worker
+    if (m_thread && m_thread->isRunning()) {
+        QMetaObject::invokeMethod(m_worker, "closePort", Qt::BlockingQueuedConnection);
+        m_thread->quit();
+        m_thread->wait(5000);
+        if (m_thread->isRunning())
+            m_thread->terminate();
+    }
 }
 
 void MainWindow::setupUi()
 {
-    auto *mainSplitter = new QSplitter(Qt::Horizontal, this);
+    // ── Outer horizontal splitter: (Raw+Table tabs) | right panel ────────────
+    m_mainSplitter = new QSplitter(Qt::Horizontal, this);
+    auto *mainSplitter = m_mainSplitter;
     mainSplitter->setHandleWidth(5);
 
+    // Left: tabs for Raw and Table views
     auto *tabs = new QTabWidget(mainSplitter);
     tabs->setTabPosition(QTabWidget::South);
 
@@ -63,12 +97,26 @@ void MainWindow::setupUi()
     m_tableView = new TableView(tabs);
     tabs->addTab(m_tableView, tr("Table view"));
 
-    m_tagWidget = new TagWidget(mainSplitter);
+    // Right: vertical splitter – Tag Monitor on top, Video below
-    m_tagWidget->setMinimumWidth(220);
+    m_rightSplitter = new QSplitter(Qt::Vertical, mainSplitter);
-    m_tagWidget->setMaximumWidth(420);
+    auto *rightSplitter = m_rightSplitter;
+    rightSplitter->setHandleWidth(5);
+    rightSplitter->setMinimumWidth(240);
+    rightSplitter->setMaximumWidth(480);
+
+    m_tagWidget = new TagWidget(rightSplitter);
+    m_videoWidget = new VideoWidget(rightSplitter);
+    m_videoWidget->setMinimumHeight(160);
+
+    rightSplitter->addWidget(m_tagWidget);
+    rightSplitter->addWidget(m_videoWidget);
+    // Initial split: ~30% tags, ~70% video – user can drag to taste
+    rightSplitter->setStretchFactor(0, 1);
+    rightSplitter->setStretchFactor(1, 2);
+    rightSplitter->setSizes({330, 330});
 
     mainSplitter->addWidget(tabs);
-    mainSplitter->addWidget(m_tagWidget);
+    mainSplitter->addWidget(rightSplitter);
     mainSplitter->setStretchFactor(0, 3);
     mainSplitter->setStretchFactor(1, 1);
 
@@ -124,10 +172,23 @@ void MainWindow::setupToolBar()
 
     tb->addSeparator();
 
+    // ── Tag filter ────────────────────────────────────────────────────────────
+    auto *filterAction = tb->addAction(tr("Tag filter…"));
+    filterAction->setToolTip(tr("Choose which tags are hidden from the Raw view"));
+    connect(filterAction, &QAction::triggered, this, &MainWindow::configureTagFilter);
+
+    tb->addSeparator();
+
     // ── Format reference ──────────────────────────────────────────────────────
     auto *helpAction = tb->addAction(tr("Format reference"));
     helpAction->setToolTip(tr("Show UARTScope output format guide (copy for AI)"));
     connect(helpAction, &QAction::triggered, this, &MainWindow::showFormatReference);
+
+    tb->addSeparator();
+
+    // ── About ─────────────────────────────────────────────────────────────────
+    auto *aboutAction = tb->addAction(tr("Über UARTScope"));
+    connect(aboutAction, &QAction::triggered, this, &MainWindow::showAbout);
 }
 
 void MainWindow::setupStatusBar()
@@ -231,7 +292,7 @@ void MainWindow::onError(const QString &message)
 
 void MainWindow::onNewLine(const QString &line)
 {
-    m_rawView->appendLine(line);
+    m_rawView->appendLine(line, m_suppressedTags);
     m_tableView->appendLine(line);
 }
 
@@ -392,3 +453,196 @@ void uart_status_update(void) {
     dlg->exec();
     dlg->deleteLater();
 }
+
+// ── Tag filter dialog ──────────────────────────────────────────────────────
+
+void MainWindow::configureTagFilter()
+{
+    auto *dlg = new QDialog(this);
+    dlg->setWindowTitle(tr("Tag filter – Raw view"));
+    dlg->setMinimumWidth(340);
+
+    auto *layout = new QVBoxLayout(dlg);
+
+    auto *infoLabel = new QLabel(
+        tr("Tags listed here are <b>hidden from the Raw view</b> and only "
+           "appear in the Tag Monitor panel.<br>"
+           "Enter one tag name per line, without brackets (e.g. <tt>WDG</tt>)."), dlg);
+    infoLabel->setWordWrap(true);
+    layout->addWidget(infoLabel);
+
+    auto *edit = new QPlainTextEdit(dlg);
+    QFont mono("Monospace");
+    mono.setStyleHint(QFont::Monospace);
+    edit->setFont(mono);
+    // Pre-populate with current filter
+    QStringList current(m_suppressedTags.values());
+    current.sort();
+    edit->setPlainText(current.join('\n'));
+    layout->addWidget(edit, 1);
+
+    auto *btnBox = new QDialogButtonBox(
+        QDialogButtonBox::Ok | QDialogButtonBox::Cancel, dlg);
+    connect(btnBox, &QDialogButtonBox::accepted, dlg, &QDialog::accept);
+    connect(btnBox, &QDialogButtonBox::rejected, dlg, &QDialog::reject);
+    layout->addWidget(btnBox);
+
+    if (dlg->exec() == QDialog::Accepted) {
+        m_suppressedTags.clear();
+        const QStringList lines = edit->toPlainText().split('\n', Qt::SkipEmptyParts);
+        for (const QString &line : lines) {
+            const QString tag = line.trimmed().toUpper();
+            if (!tag.isEmpty())
+                m_suppressedTags.insert(tag);
+        }
+    }
+    dlg->deleteLater();
+}
+
+// ── Settings: save / restore ───────────────────────────────────────────────
+
+void MainWindow::saveSettings()
+{
+    QSettings s("ChicaDev", "UARTScope");
+
+    // Window geometry & state
+    s.setValue("window/geometry",    saveGeometry());
+    s.setValue("window/state",       saveState());
+
+    // Splitter sizes
+    if (m_mainSplitter)
+        s.setValue("splitter/main",  m_mainSplitter->saveState());
+    if (m_rightSplitter)
+        s.setValue("splitter/right", m_rightSplitter->saveState());
+
+    // Toolbar settings
+    s.setValue("reconnect/enabled",  m_autoReconnectCb->isChecked());
+    s.setValue("reconnect/interval", m_reconnectIntervalSb->value());
+
+    // Tag filter
+    QStringList tags(m_suppressedTags.values());
+    tags.sort();
+    s.setValue("tagfilter/suppressed", tags);
+}
+
+void MainWindow::restoreSettings()
+{
+    QSettings s("ChicaDev", "UARTScope");
+
+    // Window geometry & state
+    if (s.contains("window/geometry"))
+        restoreGeometry(s.value("window/geometry").toByteArray());
+    if (s.contains("window/state"))
+        restoreState(s.value("window/state").toByteArray());
+
+    // Splitter sizes (only restore if we have saved data)
+    if (m_mainSplitter && s.contains("splitter/main"))
+        m_mainSplitter->restoreState(s.value("splitter/main").toByteArray());
+    if (m_rightSplitter && s.contains("splitter/right"))
+        m_rightSplitter->restoreState(s.value("splitter/right").toByteArray());
+
+    // Toolbar settings
+    if (s.contains("reconnect/enabled"))
+        m_autoReconnectCb->setChecked(s.value("reconnect/enabled").toBool());
+    if (s.contains("reconnect/interval"))
+        m_reconnectIntervalSb->setValue(s.value("reconnect/interval").toInt());
+
+    // Tag filter
+    const QStringList tags = s.value("tagfilter/suppressed").toStringList();
+    m_suppressedTags.clear();
+    for (const QString &t : tags)
+        if (!t.isEmpty())
+            m_suppressedTags.insert(t);
+}
+
+// ── About dialog ──────────────────────────────────────────────────────────
+
+void MainWindow::showAbout()
+{
+    auto *dlg = new QDialog(this);
+    dlg->setWindowTitle(tr("Über UARTScope"));
+    dlg->setFixedSize(400, 280);
+
+    auto *root = new QVBoxLayout(dlg);
+    root->setContentsMargins(0, 0, 0, 0);
+    root->setSpacing(0);
+
+    // ── Header block (dark accent) ────────────────────────────────────────────
+    auto *header = new QWidget(dlg);
+    header->setFixedHeight(110);
+    header->setStyleSheet("background-color: #1e1e1e;");
+    auto *headerLayout = new QHBoxLayout(header);
+    headerLayout->setContentsMargins(20, 14, 24, 14);
+    headerLayout->setSpacing(16);
+
+    // Logo
+    auto *logoLabel = new QLabel(header);
+    const QPixmap logoPix(":/icons/UartscopeLogo.png");
+    logoLabel->setPixmap(logoPix.scaled(72, 72, Qt::KeepAspectRatio, Qt::SmoothTransformation));
+    logoLabel->setStyleSheet("background: transparent;");
+    logoLabel->setFixedSize(72, 72);
+
+    // Title + subtitle
+    auto *titleBlock = new QVBoxLayout();
+    titleBlock->setSpacing(4);
+    auto *titleLabel = new QLabel("UARTScope", header);
+    titleLabel->setStyleSheet(
+        "color: #ffffff; font-size: 26px; font-weight: bold; background: transparent;");
+    auto *subtitleLabel = new QLabel(tr("UART-Monitor & HDMI-Viewer für Baremetal-Entwicklung"), header);
+    subtitleLabel->setStyleSheet(
+        "color: #56b6c2; font-size: 11px; background: transparent;");
+    titleBlock->addWidget(titleLabel);
+    titleBlock->addWidget(subtitleLabel);
+
+    headerLayout->addWidget(logoLabel);
+    headerLayout->addLayout(titleBlock);
+    root->addWidget(header);
+
+    // ── Info grid ─────────────────────────────────────────────────────────────
+    auto *body = new QWidget(dlg);
+    body->setStyleSheet("background-color: #252526;");
+    auto *grid = new QGridLayout(body);
+    grid->setContentsMargins(24, 20, 24, 20);
+    grid->setVerticalSpacing(10);
+    grid->setHorizontalSpacing(16);
+    grid->setColumnMinimumWidth(0, 90);
+
+    const QString labelStyle = "color: #888888; font-weight: bold; background: transparent;";
+    const QString valueStyle = "color: #d4d4d4; background: transparent;";
+
+    auto addRow = [&](int row, const QString &label, const QString &value) {
+        auto *l = new QLabel(label, body);
+        auto *v = new QLabel(value, body);
+        l->setStyleSheet(labelStyle);
+        v->setStyleSheet(valueStyle);
+        l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+        grid->addWidget(l, row, 0);
+        grid->addWidget(v, row, 1);
+    };
+
+    addRow(0, tr("Version"),     "1.0.0");
+    addRow(1, tr("Entwickler"),  "Dany Thinnes");
+    addRow(2, tr("Projekt"),     "Projekt Hirnfrei");
+    addRow(3, tr("Framework"),   QString("Qt %1").arg(QT_VERSION_STR));
+    addRow(4, tr("Sprache"),     "C++17");
+
+    root->addWidget(body, 1);
+
+    // ── Footer with close button ──────────────────────────────────────────────
+    auto *footer = new QWidget(dlg);
+    footer->setStyleSheet("background-color: #252526; border-top: 1px solid #3c3c3c;");
+    auto *footerLayout = new QHBoxLayout(footer);
+    footerLayout->setContentsMargins(16, 10, 16, 10);
+
+    auto *closeBtn = new QPushButton(tr("Schließen"), footer);
+    closeBtn->setDefault(true);
+    closeBtn->setMinimumWidth(90);
+    connect(closeBtn, &QPushButton::clicked, dlg, &QDialog::accept);
+
+    footerLayout->addStretch();
+    footerLayout->addWidget(closeBtn);
+    root->addWidget(footer);
+
+    dlg->exec();
+    dlg->deleteLater();
+}

src/rawview.cpp

@@ -5,6 +5,11 @@
 #include <QFont>
 #include <QPalette>
 #include <QApplication>
+#include <QClipboard>
+#include <QDateTime>
+
+const QRegularExpression RawView::s_tagRe(
+    R"(\[([A-Z][A-Z0-9_]*)\])", QRegularExpression::CaseInsensitiveOption);
 
 RawView::RawView(QWidget *parent)
     : QWidget(parent)
@@ -15,7 +20,7 @@ RawView::RawView(QWidget *parent)
 
 void RawView::setupUi()
 {
-    auto *mainLayout   = new QVBoxLayout(this);
+    auto *mainLayout = new QVBoxLayout(this);
     mainLayout->setContentsMargins(4, 4, 4, 4);
     mainLayout->setSpacing(4);
 
@@ -23,7 +28,7 @@ void RawView::setupUi()
     auto *toolbar = new QHBoxLayout();
 
     m_searchEdit = new QLineEdit(this);
-    m_searchEdit->setPlaceholderText(tr("Search…  (Enter)"));
+    m_searchEdit->setPlaceholderText(tr("Search…"));
     m_searchEdit->setClearButtonEnabled(true);
     connect(m_searchEdit, &QLineEdit::textChanged, this, &RawView::onSearch);
 
@@ -31,33 +36,35 @@ void RawView::setupUi()
     m_autoScrollCb->setChecked(true);
     connect(m_autoScrollCb, &QCheckBox::toggled, this, &RawView::onAutoScrollToggled);
 
-    m_clearBtn = new QPushButton(tr("Clear"), this);
-    connect(m_clearBtn, &QPushButton::clicked, this, &RawView::clear);
-
     m_lineCountLbl = new QLabel(tr("Lines: 0"), this);
     m_lineCountLbl->setMinimumWidth(90);
 
+    m_copyBtn = new QPushButton(tr("📋 Copy"), this);
+    m_copyBtn->setToolTip(tr("Copy all raw output to clipboard"));
+    connect(m_copyBtn, &QPushButton::clicked, this, &RawView::copyToClipboard);
+
+    m_clearBtn = new QPushButton(tr("Clear"), this);
+    connect(m_clearBtn, &QPushButton::clicked, this, &RawView::clear);
+
     toolbar->addWidget(new QLabel(tr("Search:"), this));
     toolbar->addWidget(m_searchEdit, 1);
     toolbar->addWidget(m_autoScrollCb);
     toolbar->addWidget(m_lineCountLbl);
+    toolbar->addWidget(m_copyBtn);
     toolbar->addWidget(m_clearBtn);
     mainLayout->addLayout(toolbar);
 
-    // ── Text area ────────────────────────────────────────────────────────────
+    // ── Text area ─────────────────────────────────────────────────────────────
     m_textEdit = new QPlainTextEdit(this);
     m_textEdit->setReadOnly(true);
-    m_textEdit->setLineWrapMode(QPlainTextEdit::NoWrap);   // horizontal scroll
+    m_textEdit->setLineWrapMode(QPlainTextEdit::NoWrap);
-    // Practically unlimited history (Qt uses a block count limit internally)
+    m_textEdit->setMaximumBlockCount(0);  // unlimited
-    m_textEdit->setMaximumBlockCount(0);  // 0 = unlimited
 
-    // Monospaced font for alignment
     QFont monoFont("Monospace");
     monoFont.setStyleHint(QFont::Monospace);
     monoFont.setPointSize(10);
     m_textEdit->setFont(monoFont);
 
-    // Don't let the text edit swallow horizontal scroll events from the viewport
     m_textEdit->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     m_textEdit->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 
@@ -69,31 +76,48 @@ void RawView::setupUi()
 
 void RawView::applyColorScheme()
 {
-    // Dark terminal style
     QPalette p = m_textEdit->palette();
-    p.setColor(QPalette::Base,  QColor(0x1e, 0x1e, 0x1e));
+    p.setColor(QPalette::Base, QColor(0x1e, 0x1e, 0x1e));
-    p.setColor(QPalette::Text,  QColor(0xd4, 0xd4, 0xd4));
+    p.setColor(QPalette::Text, QColor(0xd4, 0xd4, 0xd4));
     m_textEdit->setPalette(p);
 }
 
-void RawView::appendLine(const QString &line)
+void RawView::appendLine(const QString &line, const QSet<QString> &suppressedTags)
 {
+    // Check whether this line belongs to a suppressed tag
+    if (!suppressedTags.isEmpty()) {
+        const auto match = s_tagRe.match(line);
+        if (match.hasMatch()) {
+            if (suppressedTags.contains(match.captured(1).toUpper()))
+                return;   // silently drop – it goes to the Tag Monitor only
+        }
+    }
+
     ++m_lineCount;
     m_lineCountLbl->setText(tr("Lines: %1").arg(m_lineCount));
 
-    // Highlight lines that contain a tag like [WDG]
+    // Prepend timestamp
-    static const QRegularExpression tagRe(R"(\[[A-Z][A-Z0-9_]*\])",
+    const QString ts = QDateTime::currentDateTime().toString("hh:mm:ss.zzz");
-                                          QRegularExpression::CaseInsensitiveOption);
+    const QString displayLine = QStringLiteral("[%1]  %2").arg(ts, line);
-    if (tagRe.match(line).hasMatch()) {
+
-        // Append as HTML so we can colour it differently
+    // Colour tag lines cyan, everything else default
-        QTextCursor cursor(m_textEdit->document());
+    const bool hasTag = s_tagRe.match(line).hasMatch();
-        cursor.movePosition(QTextCursor::End);
+
-        QTextCharFormat fmt;
+    QTextCursor cursor(m_textEdit->document());
-        fmt.setForeground(QColor(0x56, 0xb6, 0xc2));  // cyan-ish
+    cursor.movePosition(QTextCursor::End);
-        cursor.insertText(line + '\n', fmt);
+
-    } else {
+    QTextCharFormat fmt;
-        m_textEdit->appendPlainText(line);
+    if (hasTag)
-    }
+        fmt.setForeground(QColor(0x56, 0xb6, 0xc2));  // cyan
+    else
+        fmt.setForeground(QColor(0xd4, 0xd4, 0xd4));  // default
+
+    // Dim the timestamp portion
+    QTextCharFormat tsFmt;
+    tsFmt.setForeground(QColor(0x60, 0x60, 0x60));
+
+    cursor.insertText(QStringLiteral("[%1]  ").arg(ts), tsFmt);
+    cursor.insertText(line + '\n', fmt);
 
     if (m_autoScroll)
         m_textEdit->verticalScrollBar()->setValue(
@@ -107,9 +131,13 @@ void RawView::clear()
     m_lineCountLbl->setText(tr("Lines: 0"));
 }
 
+void RawView::copyToClipboard()
+{
+    QApplication::clipboard()->setText(m_textEdit->toPlainText());
+}
+
 void RawView::onSearch(const QString &text)
 {
-    // Simple incremental search – highlight first match
     QTextDocument *doc = m_textEdit->document();
     QTextCursor cursor = doc->find(text);
     if (!cursor.isNull()) {
@@ -124,9 +152,7 @@ void RawView::onSearch(const QString &text)
 
 void RawView::onScrollValueChanged(int value)
 {
-    const int max = m_textEdit->verticalScrollBar()->maximum();
+    if (value < m_textEdit->verticalScrollBar()->maximum() - 5) {
-    // If user scrolled away from bottom, disable auto-scroll
-    if (value < max - 5) {
         m_autoScroll = false;
         m_autoScrollCb->setChecked(false);
     }

src/tagpanel.cpp

@@ -1,21 +1,18 @@
 #include "tagpanel.h"
 #include <QHeaderView>
 #include <QRegularExpression>
+#include <QApplication>
+#include <QClipboard>
 
 TagPanel::TagPanel(const QString &tag, QWidget *parent)
     : QGroupBox(QStringLiteral("[%1]").arg(tag), parent)
     , m_tag(tag)
 {
     auto *layout = new QVBoxLayout(this);
-    layout->setContentsMargins(6, 12, 6, 6);
+    layout->setContentsMargins(6, 14, 6, 6);
     layout->setSpacing(4);
 
-    // Timestamp line
+    // ── Table for key=value pairs ─────────────────────────────────────────────
-    m_timestampLabel = new QLabel(tr("No data yet"), this);
-    m_timestampLabel->setStyleSheet("color: gray; font-size: 10px;");
-    layout->addWidget(m_timestampLabel);
-
-    // Table for key=value pairs
     m_table = new QTableWidget(0, 2, this);
     m_table->setHorizontalHeaderLabels({tr("Key"), tr("Value")});
     m_table->horizontalHeader()->setStretchLastSection(true);
@@ -26,23 +23,28 @@ TagPanel::TagPanel(const QString &tag, QWidget *parent)
     m_table->verticalHeader()->setDefaultSectionSize(22);
     layout->addWidget(m_table);
 
-    // Fallback label for non-kv data
+    // ── Fallback label for non-kv data ────────────────────────────────────────
     m_rawLabel = new QLabel(this);
     m_rawLabel->setWordWrap(true);
     m_rawLabel->setStyleSheet("font-family: monospace;");
     m_rawLabel->hide();
     layout->addWidget(m_rawLabel);
+
+    // ── Copy button ───────────────────────────────────────────────────────────
+    auto *btnRow = new QHBoxLayout();
+    btnRow->addStretch();
+    auto *copyBtn = new QPushButton(tr("📋 Copy"), this);
+    copyBtn->setToolTip(tr("Copy current tag values to clipboard"));
+    copyBtn->setMaximumWidth(90);
+    connect(copyBtn, &QPushButton::clicked, this, &TagPanel::copyToClipboard);
+    btnRow->addWidget(copyBtn);
+    layout->addLayout(btnRow);
 }
 
 void TagPanel::update(const QString &value)
 {
-    m_timestampLabel->setText(
-        QDateTime::currentDateTime().toString("hh:mm:ss.zzz"));
-
-    // Detect key=value format: word=anything (space separated)
     static const QRegularExpression kvRe(R"((\w+)=(\S+))");
-    auto it = kvRe.globalMatch(value);
+    if (kvRe.match(value).hasMatch()) {
-    if (it.hasNext()) {
         parseKeyValue(value);
         m_rawLabel->hide();
         m_table->show();
@@ -59,13 +61,10 @@ void TagPanel::parseKeyValue(const QString &value)
     auto it = kvRe.globalMatch(value);
     while (it.hasNext()) {
         const auto match = it.next();
-        const QString key = match.captured(1);
+        ensureRow(match.captured(1));
-        const QString val = match.captured(2);
+        const int row = m_keys.indexOf(match.captured(1));
-        ensureRow(key);
+        m_table->item(row, 1)->setText(match.captured(2));
-        const int row = m_keys.indexOf(key);
+        m_table->item(row, 1)->setBackground(QColor(0x2d, 0x5a, 0x2d));  // flash green
-        m_table->item(row, 1)->setText(val);
-        // Flash highlight
-        m_table->item(row, 1)->setBackground(QColor(0x2d, 0x5a, 0x2d));
     }
 }
 
@@ -84,3 +83,21 @@ void TagPanel::ensureRow(const QString &key)
     m_table->setItem(row, 0, new QTableWidgetItem(key));
     m_table->setItem(row, 1, new QTableWidgetItem(QString()));
 }
+
+void TagPanel::copyToClipboard()
+{
+    QStringList lines;
+    lines << QStringLiteral("[%1]").arg(m_tag);
+
+    if (m_table->isVisible()) {
+        for (int r = 0; r < m_table->rowCount(); ++r) {
+            const QString key = m_table->item(r, 0)->text();
+            const QString val = m_table->item(r, 1)->text();
+            lines << QStringLiteral("  %1 = %2").arg(key, val);
+        }
+    } else {
+        lines << QStringLiteral("  %1").arg(m_rawLabel->text());
+    }
+
+    QApplication::clipboard()->setText(lines.join('\n'));
+}

src/v4l2worker.cpp

@@ -0,0 +1,288 @@
+#include "v4l2worker.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <errno.h>
+#include <string.h>
+#include <linux/videodev2.h>
+
+#include <QBuffer>
+#include <QImageReader>
+#include <QThread>
+
+static int xioctl(int fd, unsigned long req, void *arg)
+{
+    int r;
+    do { r = ::ioctl(fd, req, arg); } while (r == -1 && errno == EINTR);
+    return r;
+}
+
+V4l2Worker::V4l2Worker(QObject *parent)
+    : QObject(parent)
+{}
+
+V4l2Worker::~V4l2Worker()
+{
+    stop();
+}
+
+// ── public slots ──────────────────────────────────────────────────────────────
+
+void V4l2Worker::startCapture(const QString &device, int width, int height)
+{
+    if (m_running.load())
+        stop();
+
+    if (!openDevice(device, width, height))
+        return;
+
+    m_running.store(true);
+
+    // Run the blocking capture loop in a plain std::thread so the Qt event
+    // loop of this worker object stays responsive to stopCapture() signals.
+    m_captureThread = std::thread([this] { captureLoop(); });
+}
+
+void V4l2Worker::stopCapture()
+{
+    stop();
+}
+
+// ── internal stop (safe to call from any thread) ──────────────────────────────
+
+void V4l2Worker::stop()
+{
+    m_running.store(false);
+    if (m_captureThread.joinable())
+        m_captureThread.join();   // wait for captureLoop() to exit
+    closeDevice();
+}
+
+// ── capture loop (runs in m_captureThread) ────────────────────────────────────
+
+void V4l2Worker::captureLoop()
+{
+    v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    if (xioctl(m_fd, VIDIOC_STREAMON, &type) == -1) {
+        emit errorOccurred(tr("VIDIOC_STREAMON failed: %1").arg(strerror(errno)));
+        m_running.store(false);
+        return;
+    }
+
+    while (m_running.load()) {
+        fd_set fds;
+        FD_ZERO(&fds);
+        FD_SET(m_fd, &fds);
+        timeval tv{0, 100000};   // 100 ms timeout → checks m_running 10x/sec
+        const int r = ::select(m_fd + 1, &fds, nullptr, nullptr, &tv);
+        if (r == 0) continue;
+        if (r == -1) {
+            if (errno == EINTR) continue;
+            emit errorOccurred(tr("select() failed: %1").arg(strerror(errno)));
+            break;
+        }
+
+        v4l2_buffer buf{};
+        buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        buf.memory = V4L2_MEMORY_MMAP;
+        if (xioctl(m_fd, VIDIOC_DQBUF, &buf) == -1) {
+            if (errno == EAGAIN) continue;
+            emit errorOccurred(tr("VIDIOC_DQBUF failed: %1").arg(strerror(errno)));
+            break;
+        }
+
+        const QImage img = convertToImage(
+            m_buffers[buf.index].start, buf.bytesused, m_width, m_height);
+        if (!img.isNull())
+            emit newFrame(img);
+
+        if (xioctl(m_fd, VIDIOC_QBUF, &buf) == -1) {
+            emit errorOccurred(tr("VIDIOC_QBUF failed: %1").arg(strerror(errno)));
+            break;
+        }
+    }
+
+    xioctl(m_fd, VIDIOC_STREAMOFF, &type);
+    emit captureStopped();
+}
+
+// ── device open / close ───────────────────────────────────────────────────────
+
+bool V4l2Worker::openDevice(const QString &device, int width, int height)
+{
+    m_width  = width;
+    m_height = height;
+
+    m_fd = ::open(device.toLocal8Bit().constData(), O_RDWR | O_NONBLOCK);
+    if (m_fd == -1) {
+        emit errorOccurred(tr("Cannot open %1: %2").arg(device, strerror(errno)));
+        return false;
+    }
+
+    v4l2_capability cap{};
+    if (xioctl(m_fd, VIDIOC_QUERYCAP, &cap) == -1) {
+        emit errorOccurred(tr("VIDIOC_QUERYCAP failed: %1").arg(strerror(errno)));
+        closeDevice();
+        return false;
+    }
+    if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
+        emit errorOccurred(tr("%1 is not a video capture device").arg(device));
+        closeDevice();
+        return false;
+    }
+
+    const uint32_t preferred[] = {
+        V4L2_PIX_FMT_MJPEG,
+        V4L2_PIX_FMT_YUYV,
+        V4L2_PIX_FMT_NV12,
+        0
+    };
+
+    m_pixFmt = 0;
+    for (int i = 0; preferred[i]; ++i) {
+        v4l2_format fmt{};
+        fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        fmt.fmt.pix.width       = static_cast<uint32_t>(width);
+        fmt.fmt.pix.height      = static_cast<uint32_t>(height);
+        fmt.fmt.pix.pixelformat = preferred[i];
+        fmt.fmt.pix.field       = V4L2_FIELD_ANY;
+        if (xioctl(m_fd, VIDIOC_S_FMT, &fmt) == 0) {
+            m_pixFmt = fmt.fmt.pix.pixelformat;
+            m_width  = static_cast<int>(fmt.fmt.pix.width);
+            m_height = static_cast<int>(fmt.fmt.pix.height);
+            break;
+        }
+    }
+    if (!m_pixFmt) {
+        emit errorOccurred(tr("No supported pixel format found on %1").arg(device));
+        closeDevice();
+        return false;
+    }
+
+    QString fmtName;
+    switch (m_pixFmt) {
+        case V4L2_PIX_FMT_MJPEG: fmtName = "MJPEG"; break;
+        case V4L2_PIX_FMT_YUYV:  fmtName = "YUYV";  break;
+        case V4L2_PIX_FMT_NV12:  fmtName = "NV12";  break;
+        default:                  fmtName = "?";     break;
+    }
+
+    if (!initMmap()) {
+        closeDevice();
+        return false;
+    }
+
+    emit captureStarted(device, m_width, m_height, fmtName);
+    return true;
+}
+
+void V4l2Worker::closeDevice()
+{
+    freeMmap();
+    if (m_fd != -1) {
+        ::close(m_fd);
+        m_fd = -1;
+    }
+}
+
+bool V4l2Worker::initMmap()
+{
+    v4l2_requestbuffers req{};
+    req.count  = MMAP_BUFFERS;
+    req.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    req.memory = V4L2_MEMORY_MMAP;
+    if (xioctl(m_fd, VIDIOC_REQBUFS, &req) == -1) {
+        emit errorOccurred(tr("VIDIOC_REQBUFS failed: %1").arg(strerror(errno)));
+        return false;
+    }
+    m_nBuffers = static_cast<int>(req.count);
+
+    for (int i = 0; i < m_nBuffers; ++i) {
+        v4l2_buffer buf{};
+        buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        buf.memory = V4L2_MEMORY_MMAP;
+        buf.index  = static_cast<uint32_t>(i);
+        if (xioctl(m_fd, VIDIOC_QUERYBUF, &buf) == -1) {
+            emit errorOccurred(tr("VIDIOC_QUERYBUF failed: %1").arg(strerror(errno)));
+            return false;
+        }
+        m_buffers[i].length = buf.length;
+        m_buffers[i].start  = ::mmap(nullptr, buf.length,
+                                      PROT_READ | PROT_WRITE, MAP_SHARED,
+                                      m_fd, buf.m.offset);
+        if (m_buffers[i].start == MAP_FAILED) {
+            emit errorOccurred(tr("mmap failed: %1").arg(strerror(errno)));
+            return false;
+        }
+        if (xioctl(m_fd, VIDIOC_QBUF, &buf) == -1) {
+            emit errorOccurred(tr("VIDIOC_QBUF failed: %1").arg(strerror(errno)));
+            return false;
+        }
+    }
+    return true;
+}
+
+void V4l2Worker::freeMmap()
+{
+    for (int i = 0; i < m_nBuffers; ++i) {
+        if (m_buffers[i].start && m_buffers[i].start != MAP_FAILED) {
+            ::munmap(m_buffers[i].start, m_buffers[i].length);
+            m_buffers[i].start = nullptr;
+        }
+    }
+    m_nBuffers = 0;
+}
+
+QImage V4l2Worker::convertToImage(const void *data, size_t size, int width, int height)
+{
+    switch (m_pixFmt) {
+    case V4L2_PIX_FMT_MJPEG: {
+        QByteArray ba(static_cast<const char *>(data), static_cast<int>(size));
+        QBuffer buf(&ba);
+        QImageReader reader(&buf, "JPEG");
+        return reader.read();
+    }
+    case V4L2_PIX_FMT_YUYV:
+        return yuyv2Rgb(static_cast<const uchar *>(data), width, height);
+    case V4L2_PIX_FMT_NV12:
+        return nv122Rgb(static_cast<const uchar *>(data), width, height);
+    default:
+        return {};
+    }
+}
+
+QImage V4l2Worker::yuyv2Rgb(const uchar *src, int width, int height)
+{
+    QImage img(width, height, QImage::Format_RGB32);
+    for (int y = 0; y < height; ++y) {
+        const uchar *row = src + y * width * 2;
+        QRgb *dst = reinterpret_cast<QRgb *>(img.scanLine(y));
+        for (int x = 0; x < width; x += 2) {
+            const int Y0 = row[0], U = row[1]-128, Y1 = row[2], V = row[3]-128;
+            row += 4;
+            auto clamp = [](int v) { return static_cast<uchar>(v<0?0:v>255?255:v); };
+            dst[x]   = qRgb(clamp(Y0+1.402f*V), clamp(Y0-0.344f*U-0.714f*V), clamp(Y0+1.772f*U));
+            dst[x+1] = qRgb(clamp(Y1+1.402f*V), clamp(Y1-0.344f*U-0.714f*V), clamp(Y1+1.772f*U));
+        }
+    }
+    return img;
+}
+
+QImage V4l2Worker::nv122Rgb(const uchar *src, int width, int height)
+{
+    QImage img(width, height, QImage::Format_RGB32);
+    const uchar *uvPlane = src + width * height;
+    auto clamp = [](int v) { return static_cast<uchar>(v<0?0:v>255?255:v); };
+    for (int y = 0; y < height; ++y) {
+        const uchar *yRow  = src + y * width;
+        const uchar *uvRow = uvPlane + (y/2) * width;
+        QRgb *dst = reinterpret_cast<QRgb *>(img.scanLine(y));
+        for (int x = 0; x < width; ++x) {
+            const int Y = yRow[x], U = uvRow[x&~1]-128, V = uvRow[(x&~1)+1]-128;
+            dst[x] = qRgb(clamp(Y+1.402f*V), clamp(Y-0.344f*U-0.714f*V), clamp(Y+1.772f*U));
+        }
+    }
+    return img;
+}

src/videowidget.cpp

@@ -0,0 +1,260 @@
+#include "videowidget.h"
+
+#include <QPainter>
+#include <QFileDialog>
+#include <QDir>
+#include <QDateTime>
+#include <QStandardPaths>
+#include <QMetaObject>
+#include <QResizeEvent>
+
+// Enumerate /dev/video* entries
+static QStringList enumerateVideoDevices()
+{
+    QStringList devices;
+    const QDir dev("/dev");
+    const auto entries = dev.entryList({"video*"}, QDir::System, QDir::Name);
+    for (const auto &e : entries)
+        devices << "/dev/" + e;
+    return devices;
+}
+
+// ── ctor / dtor ───────────────────────────────────────────────────────────────
+
+VideoWidget::VideoWidget(QWidget *parent)
+    : QWidget(parent)
+{
+    setupUi();
+
+    m_thread = new QThread(this);
+    m_worker = new V4l2Worker();
+    m_worker->moveToThread(m_thread);
+
+    connect(m_thread, &QThread::finished, m_worker, &QObject::deleteLater);
+
+    connect(m_worker, &V4l2Worker::newFrame,        this, &VideoWidget::onNewFrame,
+            Qt::QueuedConnection);
+    connect(m_worker, &V4l2Worker::captureStarted,  this, [this](const QString &dev, int w, int h, const QString &fmt) {
+        m_infoLabel->setText(tr("%1  %2×%3  %4").arg(dev).arg(w).arg(h).arg(fmt));
+        m_running = true;
+        m_startBtn->setText(tr("■ Stop"));
+    });
+    connect(m_worker, &V4l2Worker::captureStopped,  this, [this] {
+        m_running = false;
+        m_startBtn->setText(tr("▶ Start"));
+        m_infoLabel->setText(tr("Stopped"));
+        update();
+    });
+    connect(m_worker, &V4l2Worker::errorOccurred,   this, [this](const QString &msg) {
+        m_infoLabel->setText(tr("Error: %1").arg(msg));
+        m_running = false;
+        m_startBtn->setText(tr("▶ Start"));
+    });
+
+    m_thread->start();
+}
+
+void VideoWidget::shutdown()
+{
+    if (m_shutdownDone)
+        return;
+    m_shutdownDone = true;
+
+    // stopCapture() sets m_running=false and joins the std::thread internally.
+    // Must happen before we quit the Qt event thread.
+    m_worker->stopCapture();
+
+    if (m_thread && m_thread->isRunning()) {
+        m_thread->quit();
+        m_thread->wait(5000);
+        if (m_thread->isRunning())
+            m_thread->terminate();
+    }
+}
+
+VideoWidget::~VideoWidget()
+{
+    shutdown();
+}
+
+// ── UI setup ─────────────────────────────────────────────────────────────────
+
+void VideoWidget::setupUi()
+{
+    setMinimumHeight(140);
+
+    auto *layout = new QVBoxLayout(this);
+    layout->setContentsMargins(2, 2, 2, 2);
+    layout->setSpacing(3);
+
+    // ── Controls row ──────────────────────────────────────────────────────────
+    auto *ctrlRow = new QHBoxLayout();
+    ctrlRow->setSpacing(4);
+
+    m_deviceCombo = new QComboBox(this);
+    m_deviceCombo->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    refreshDeviceList();
+
+    auto *refreshBtn = new QPushButton("↻", this);
+    refreshBtn->setMaximumWidth(26);
+    refreshBtn->setToolTip(tr("Refresh device list"));
+    connect(refreshBtn, &QPushButton::clicked, this, &VideoWidget::refreshDeviceList);
+
+    m_startBtn = new QPushButton(tr("▶ Start"), this);
+    m_startBtn->setMaximumWidth(70);
+    connect(m_startBtn, &QPushButton::clicked, this, &VideoWidget::onStartStop);
+
+    m_freezeBtn = new QPushButton(tr("❚❚ Freeze"), this);
+    m_freezeBtn->setCheckable(true);
+    m_freezeBtn->setMaximumWidth(80);
+    connect(m_freezeBtn, &QPushButton::toggled, this, &VideoWidget::onFreeze);
+
+    m_screenshotBtn = new QPushButton(tr("📷"), this);
+    m_screenshotBtn->setMaximumWidth(32);
+    m_screenshotBtn->setToolTip(tr("Save screenshot (PNG/JPG)"));
+    connect(m_screenshotBtn, &QPushButton::clicked, this, &VideoWidget::onScreenshot);
+
+    ctrlRow->addWidget(m_deviceCombo, 1);
+    ctrlRow->addWidget(refreshBtn);
+    ctrlRow->addWidget(m_startBtn);
+    ctrlRow->addWidget(m_freezeBtn);
+    ctrlRow->addWidget(m_screenshotBtn);
+    layout->addLayout(ctrlRow);
+
+    // ── Info label ────────────────────────────────────────────────────────────
+    m_infoLabel = new QLabel(tr("No device started"), this);
+    m_infoLabel->setStyleSheet("color: gray; font-size: 9px;");
+    layout->addWidget(m_infoLabel);
+
+    // The video frame is drawn directly in paintEvent – no QLabel needed.
+    // We leave stretch space for it.
+    layout->addStretch(1);
+}
+
+// ── Slots ─────────────────────────────────────────────────────────────────────
+
+void VideoWidget::onStartStop()
+{
+    if (m_running)
+        stopCapture();
+    else
+        startCapture();
+}
+
+void VideoWidget::onFreeze(bool frozen)
+{
+    m_frozen = frozen;
+    m_freezeBtn->setText(frozen ? tr("▶ Live") : tr("❚❚ Freeze"));
+}
+
+void VideoWidget::onScreenshot()
+{
+    if (m_frame.isNull())
+        return;
+
+    const QString defaultName =
+        QStandardPaths::writableLocation(QStandardPaths::PicturesLocation)
+        + "/uartscope_"
+        + QDateTime::currentDateTime().toString("yyyyMMdd_hhmmss")
+        + ".png";
+
+    const QString path = QFileDialog::getSaveFileName(
+        this, tr("Save screenshot"), defaultName,
+        tr("PNG Image (*.png);;JPEG Image (*.jpg *.jpeg)"));
+
+    if (!path.isEmpty())
+        m_frame.save(path);
+}
+
+void VideoWidget::onNewFrame(const QImage &frame)
+{
+    if (m_frozen)
+        return;
+    m_frame = frame;
+    updateScaled();
+    update();   // trigger paintEvent
+}
+
+void VideoWidget::refreshDeviceList()
+{
+    const QString current = m_deviceCombo->currentText();
+    m_deviceCombo->clear();
+    const auto devices = enumerateVideoDevices();
+    for (const auto &d : devices)
+        m_deviceCombo->addItem(d);
+    // Restore previous selection if still present
+    const int idx = m_deviceCombo->findText(current);
+    if (idx >= 0)
+        m_deviceCombo->setCurrentIndex(idx);
+}
+
+// ── Capture start/stop ────────────────────────────────────────────────────────
+
+void VideoWidget::startCapture()
+{
+    const QString dev = m_deviceCombo->currentText();
+    if (dev.isEmpty())
+        return;
+    m_frame = QImage();
+    m_scaled = QImage();
+    // startCapture blocks in the worker thread until stopCapture() is called
+    QMetaObject::invokeMethod(m_worker, "startCapture",
+        Qt::QueuedConnection,
+        Q_ARG(QString, dev),
+        Q_ARG(int, 1920),
+        Q_ARG(int, 1080));
+}
+
+void VideoWidget::stopCapture()
+{
+    QMetaObject::invokeMethod(m_worker, "stopCapture", Qt::QueuedConnection);
+}
+
+// ── Paint ─────────────────────────────────────────────────────────────────────
+
+void VideoWidget::updateScaled()
+{
+    // Video area = widget height minus the two control rows (~55 px)
+    const QRect videoRect(0, 55, width(), height() - 55);
+    if (videoRect.width() < 10 || videoRect.height() < 10 || m_frame.isNull())
+        return;
+
+    m_scaled = m_frame.scaled(videoRect.size(), Qt::KeepAspectRatio,
+                               Qt::SmoothTransformation);
+}
+
+void VideoWidget::paintEvent(QPaintEvent *)
+{
+    QPainter p(this);
+
+    // Background
+    p.fillRect(rect(), QColor(0x10, 0x10, 0x10));
+
+    if (m_scaled.isNull()) {
+        p.setPen(QColor(0x44, 0x44, 0x44));
+        p.drawText(rect(), Qt::AlignCenter,
+                   m_running ? tr("Waiting for frames…") : tr("No signal"));
+        return;
+    }
+
+    // Centre the scaled frame in the video area
+    const QRect videoRect(0, 55, width(), height() - 55);
+    const QPoint origin(
+        videoRect.left() + (videoRect.width()  - m_scaled.width())  / 2,
+        videoRect.top()  + (videoRect.height() - m_scaled.height()) / 2);
+    p.drawImage(origin, m_scaled);
+
+    // Frozen overlay
+    if (m_frozen) {
+        p.setPen(QColor(0xff, 0xcc, 0x00));
+        p.setFont(QFont("Sans", 9, QFont::Bold));
+        p.drawText(videoRect.adjusted(4, 4, -4, -4),
+                   Qt::AlignTop | Qt::AlignRight, tr("FREEZE"));
+    }
+}
+
+void VideoWidget::resizeEvent(QResizeEvent *event)
+{
+    QWidget::resizeEvent(event);
+    updateScaled();
+}

uartscope-git/PKGBUILD

@@ -1,6 +1,6 @@
 # Maintainer: diabolus <your@email.com>
 pkgname=uartscope
-pkgver=1.0.0
+pkgver=1.0.0.r1.g2181f25
 pkgrel=1
 pkgdesc="Qt6-based UART serial monitor with tag monitoring, table view and auto-reconnect"
 arch=('x86_64' 'aarch64')

uartscope-git/pkg/uartscope/.PKGINFO

@@ -0,0 +1,19 @@
+# Generated by makepkg 7.1.0
+# using fakeroot version 1.38.1
+pkgname = uartscope
+pkgbase = uartscope
+xdata = pkgtype=pkg
+pkgver = 1.0.0.r1.g2181f25-1
+pkgdesc = Qt6-based UART serial monitor with tag monitoring, table view and auto-reconnect
+url = https://git.projekt-hirnfrei.de/diabolus/uartscope
+builddate = 1780988717
+packager = Unknown Packager
+size = 209170
+arch = x86_64
+license = MIT
+conflict = uartscope
+provides = uartscope
+depend = qt6-base
+depend = qt6-serialport
+makedepend = cmake
+makedepend = git

uartscope-git/pkg/uartscope/usr/share/applications/uartscope.desktop

@@ -0,0 +1,8 @@
+[Desktop Entry]
+Name=UARTScope
+Comment=UART Serial Monitor
+Exec=uartscope
+Icon=utilities-terminal
+Terminal=false
+Type=Application
+Categories=Development;Utility;

uartscope-git/uartscope/FETCH_HEAD

@@ -0,0 +1,2 @@
+2181f254d29960cffe3b1f6158a97b3c65fb0d15	not-for-merge	branch 'main' of https://git.projekt-hirnfrei.de/diabolus/uartscope
+cc102c93eb17f7b910d8e74c3505f198bed77f10	not-for-merge	tag 'v1.0.0' of https://git.projekt-hirnfrei.de/diabolus/uartscope

uartscope-git/uartscope/HEAD

@@ -0,0 +1 @@
+ref: refs/heads/main

uartscope-git/uartscope/config

@@ -0,0 +1,9 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = true
+[remote "origin"]
+	url = https://git.projekt-hirnfrei.de/diabolus/uartscope.git
+	tagOpt = --no-tags
+	fetch = +refs/*:refs/*
+	mirror = true

uartscope-git/uartscope/description

@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.

uartscope-git/uartscope/hooks/applypatch-msg.sample

@@ -0,0 +1,15 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message taken by
+# applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "applypatch-msg".
+
+. git-sh-setup
+commitmsg="$(git rev-parse --git-path hooks/commit-msg)"
+test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"}
+:

uartscope-git/uartscope/hooks/commit-msg.sample

@@ -0,0 +1,74 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message.
+# Called by "git commit" with one argument, the name of the file
+# that has the commit message.  The hook should exit with non-zero
+# status after issuing an appropriate message if it wants to stop the
+# commit.  The hook is allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "commit-msg".
+
+# Uncomment the below to add a Signed-off-by line to the message.
+# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
+# hook is more suited to it.
+#
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
+
+# This example catches duplicate Signed-off-by lines and messages that
+# would confuse 'git am'.
+
+ret=0
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	ret=1
+}
+
+comment_re="$(
+	{
+		git config --get-regexp "^core\.comment(char|string)\$" ||
+			echo '#'
+	} | sed -n -e '
+		${
+			s/^[^ ]* //
+			s|[][*./\]|\\&|g
+			s/^auto$/[#;@!$%^&|:]/
+			p
+		}'
+)"
+scissors_line="^${comment_re} -\{8,\} >8 -\{8,\}\$"
+comment_line="^${comment_re}.*"
+blank_line='^[ 	]*$'
+# Disallow lines starting with "diff -" or "Index: " in the body of the
+# message. Stop looking if we see a scissors line.
+line="$(sed -n -e "
+	# Skip comments and blank lines at the start of the file.
+	/${scissors_line}/q
+	/${comment_line}/d
+	/${blank_line}/d
+	# The first paragraph will become the subject header so
+	# does not need to be checked.
+	: subject
+	n
+	/${scissors_line}/q
+	/${blank_line}/!b subject
+	# Check the body of the message for problematic
+	# prefixes.
+	: body
+	n
+	/${scissors_line}/q
+	/${comment_line}/b body
+	/^diff -/{p;q;}
+	/^Index: /{p;q;}
+	b body
+	" "$1")"
+if test -n "$line"
+then
+	echo >&2 "Message contains a diff that will confuse 'git am'."
+	echo >&2 "To fix this indent the diff."
+	ret=1
+fi
+
+exit $ret

uartscope-git/uartscope/hooks/fsmonitor-watchman.sample

@@ -0,0 +1,168 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	    "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	my $last_update_line = "";
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+		$last_update_line = qq[\n"since": $last_update_token,];
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {$last_update_line
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		    "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $o->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

uartscope-git/uartscope/hooks/post-update.sample

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# An example hook script to prepare a packed repository for use over
+# dumb transports.
+#
+# To enable this hook, rename this file to "post-update".
+
+exec git update-server-info

uartscope-git/uartscope/hooks/pre-applypatch.sample

@@ -0,0 +1,14 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-applypatch".
+
+. git-sh-setup
+precommit="$(git rev-parse --git-path hooks/pre-commit)"
+test -x "$precommit" && exec "$precommit" ${1+"$@"}
+:

uartscope-git/uartscope/hooks/pre-commit.sample

@@ -0,0 +1,49 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git commit" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# Note that the use of brackets around a tr range is ok here, (it's
+	# even required, for portability to Solaris 10's /usr/bin/tr), since
+	# the square bracket bytes happen to fall in the designated range.
+	test $(git diff-index --cached --name-only --diff-filter=A -z $against |
+	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+  git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

uartscope-git/uartscope/hooks/pre-merge-commit.sample

@@ -0,0 +1,13 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git merge" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message to
+# stderr if it wants to stop the merge commit.
+#
+# To enable this hook, rename this file to "pre-merge-commit".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/pre-commit" &&
+        exec "$GIT_DIR/hooks/pre-commit"
+:

uartscope-git/uartscope/hooks/pre-push.sample

@@ -0,0 +1,53 @@
+#!/bin/sh
+
+# An example hook script to verify what is about to be pushed.  Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed.  If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+#   <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

uartscope-git/uartscope/hooks/pre-rebase.sample

@@ -0,0 +1,169 @@
+#!/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master.  Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next?  If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master           ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+   merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+   it is deleted.  If you need to build on top of it to correct
+   earlier mistakes, a new topic branch is created by forking at
+   the tip of the "master".  This is not strictly necessary, but
+   it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+   branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next".  Young
+    topic branches can have stupid mistakes you would rather
+    clean up before publishing, and things that have not been
+    merged into other branches can be easily rebased without
+    affecting other people.  But once it is published, you would
+    not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+    Then you can delete it.  More importantly, you should not
+    build on top of it -- other people may already want to
+    change things related to the topic as patches against your
+    "master", so if you need further changes, it is better to
+    fork the topic (perhaps with the same name) afresh from the
+    tip of "master".
+
+Let's look at this example:
+
+		   o---o---o---o---o---o---o---o---o---o "next"
+		  /       /           /           /
+		 /   a---a---b A     /           /
+		/   /               /           /
+	       /   /   c---c---c---c B         /
+	      /   /   /             \         /
+	     /   /   /   b---b C     \       /
+	    /   /   /   /             \     /
+    ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished.  It has been fully merged up to "master" and "next",
+   and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master        next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

uartscope-git/uartscope/hooks/pre-receive.sample

@@ -0,0 +1,24 @@
+#!/bin/sh
+#
+# An example hook script to make use of push options.
+# The example simply echoes all push options that start with 'echoback='
+# and rejects all pushes when the "reject" push option is used.
+#
+# To enable this hook, rename this file to "pre-receive".
+
+if test -n "$GIT_PUSH_OPTION_COUNT"
+then
+	i=0
+	while test "$i" -lt "$GIT_PUSH_OPTION_COUNT"
+	do
+		eval "value=\$GIT_PUSH_OPTION_$i"
+		case "$value" in
+		echoback=*)
+			echo "echo from the pre-receive-hook: ${value#*=}" >&2
+			;;
+		reject)
+			exit 1
+		esac
+		i=$((i + 1))
+	done
+fi

uartscope-git/uartscope/hooks/prepare-commit-msg.sample

@@ -0,0 +1,42 @@
+#!/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

uartscope-git/uartscope/hooks/push-to-checkout.sample

@@ -0,0 +1,78 @@
+#!/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+#   head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

uartscope-git/uartscope/hooks/sendemail-validate.sample

@@ -0,0 +1,77 @@
+#!/bin/sh
+
+# An example hook script to validate a patch (and/or patch series) before
+# sending it via email.
+#
+# The hook should exit with non-zero status after issuing an appropriate
+# message if it wants to prevent the email(s) from being sent.
+#
+# To enable this hook, rename this file to "sendemail-validate".
+#
+# By default, it will only check that the patch(es) can be applied on top of
+# the default upstream branch without conflicts in a secondary worktree. After
+# validation (successful or not) of the last patch of a series, the worktree
+# will be deleted.
+#
+# The following config variables can be set to change the default remote and
+# remote ref that are used to apply the patches against:
+#
+#   sendemail.validateRemote (default: origin)
+#   sendemail.validateRemoteRef (default: HEAD)
+#
+# Replace the TODO placeholders with appropriate checks according to your
+# needs.
+
+validate_cover_letter () {
+	file="$1"
+	# TODO: Replace with appropriate checks (e.g. spell checking).
+	true
+}
+
+validate_patch () {
+	file="$1"
+	# Ensure that the patch applies without conflicts.
+	git am -3 "$file" || return
+	# TODO: Replace with appropriate checks for this patch
+	# (e.g. checkpatch.pl).
+	true
+}
+
+validate_series () {
+	# TODO: Replace with appropriate checks for the whole series
+	# (e.g. quick build, coding style checks, etc.).
+	true
+}
+
+# main -------------------------------------------------------------------------
+
+if test "$GIT_SENDEMAIL_FILE_COUNTER" = 1
+then
+	remote=$(git config --default origin --get sendemail.validateRemote) &&
+	ref=$(git config --default HEAD --get sendemail.validateRemoteRef) &&
+	worktree=$(mktemp --tmpdir -d sendemail-validate.XXXXXXX) &&
+	git worktree add -fd --checkout "$worktree" "refs/remotes/$remote/$ref" &&
+	git config --replace-all sendemail.validateWorktree "$worktree"
+else
+	worktree=$(git config --get sendemail.validateWorktree)
+fi || {
+	echo "sendemail-validate: error: failed to prepare worktree" >&2
+	exit 1
+}
+
+unset GIT_DIR GIT_WORK_TREE
+cd "$worktree" &&
+
+if grep -q "^diff --git " "$1"
+then
+	validate_patch "$1"
+else
+	validate_cover_letter "$1"
+fi &&
+
+if test "$GIT_SENDEMAIL_FILE_COUNTER" = "$GIT_SENDEMAIL_FILE_TOTAL"
+then
+	git config --unset-all sendemail.validateWorktree &&
+	trap 'git worktree remove -ff "$worktree"' EXIT &&
+	validate_series
+fi

uartscope-git/uartscope/hooks/update.sample

@@ -0,0 +1,128 @@
+#!/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+#   This boolean sets whether unannotated tags will be allowed into the
+#   repository.  By default they won't be.
+# hooks.allowdeletetag
+#   This boolean sets whether deleting tags will be allowed in the
+#   repository.  By default they won't be.
+# hooks.allowmodifytag
+#   This boolean sets whether a tag may be modified after creation. By default
+#   it won't be.
+# hooks.allowdeletebranch
+#   This boolean sets whether deleting branches will be allowed in the
+#   repository.  By default they won't be.
+# hooks.denycreatebranch
+#   This boolean sets whether remotely creating branches will be denied
+#   in the repository.  By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo "  $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

uartscope-git/uartscope/info/attributes

@@ -0,0 +1 @@
+* -export-subst -export-ignore

uartscope-git/uartscope/info/exclude

@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~

uartscope-git/uartscope/packed-refs

@@ -0,0 +1,2 @@
+# pack-refs with: peeled fully-peeled sorted 
+cc102c93eb17f7b910d8e74c3505f198bed77f10 refs/heads/main

uartscope-git/uartscope/refs/tags/v1.0.0

@@ -0,0 +1 @@
+cc102c93eb17f7b910d8e74c3505f198bed77f10

uartscope.desktop.in

@@ -2,7 +2,7 @@
 Name=UARTScope
 Comment=UART Serial Monitor
 Exec=uartscope
-Icon=utilities-terminal
+Icon=uartscope
 Terminal=false
 Type=Application
 Categories=Development;Utility;