Cloner un dépôt volumineux sous Git

git clone http://github.com/large-repository --depth 1
cd large-repository
git fetch --unshallow

Installer l'extension WSL sous VSCode

VSCode > Extensions > WSL > Install

Ouvrir un dossier avec WSL sous VSCode

Barre de recherche > Show and Run Commands
> WSL: Open Folder in WSL
Dossier > v03 > Sélectionner un dossier

Installer l'extension C++ sous VSCode

VSCode > Extensions > C/C++ > Install

Installer l'extension CMake sous VSCode

VSCode > Extensions > CMake > Install
VSCode > Extensions > CMake Tools > Install

Configurer l'outil CMake

Barre de recherche > Show and Run Commands 
> CMake: Quick Start
Name : ReadyScope
C++ : Create a C++ project
Executable : Create an executable
OK > OK

Configurer le projet C++

#include <iostream>
...
int main(int argc, char *argv[])
{
    std::cout << "Démarrage de l'application..." << std::endl;
    return 0;
}

cmake_minimum_required(VERSION 3.5.0)
project(ReadyScope VERSION 0.1.0 LANGUAGES C CXX)
...
add_executable(ReadyScope main.cpp)

Compiler le projet C++

CMake Tools > Build > Run

Exécuter le projet C++

CMake Tools > Launch > Run

Placer les points d'arrêt

VSCode > Placer des points d'arrêt aux lignes de débogage souhaitées
...
Cliquer le bord gauche d'une ligne pour placer un point d'arrêt

Démarrer le débogueur

CMake Tools > Debug > Run
...
Le débogueur s'arrête au premier point d'arrêt trouvé

Visualiser les variables locales

VSCode > Debug > Variables > Locals

Visualiser la pile des apples

VSCode > Debug > Call Stacks

Configurer la commande make

MAKE_CMD="$1"
MAKE_ARGS=""
shift
...
while test $# -gt 0
do
    MAKE_ARGS="$MAKE_ARGS $1"
    shift
done
...
make -f commands.mak $MAKE_CMD ARGS="$MAKE_ARGS"

Configurer les règles de construction

SRC_DIR = ..
BUILD_DIR = ../build
TARGET_NAME = ReadyScope
SETUP_NAME = $(BUILD_DIR)/$(TARGET_NAME)
...
all: clean_exe cmake compile run
all_g: clean_exe cmake_g compile run_g
...
cmake:
	@echo
	@cmake -B $(BUILD_DIR) -S $(SRC_DIR)
cmake_g:
	@echo
	@cmake -DCMAKE_BUILD_TYPE=Debug -B $(BUILD_DIR) -S $(SRC_DIR)
compile:
	@echo
	@make -C $(BUILD_DIR)
clean_exe:
	@echo
	@rm -f $(SETUP_NAME)
clean: clean_exe
	@echo
	@make -C $(BUILD_DIR) clean
clean_all:
	@echo
	@rm -rf $(BUILD_DIR)/*
run:
	@echo
	@./envs.sh && $(SETUP_NAME) $(ARGS)
	@echo
run_g:
	@echo
	@./envs.sh && gdb --args $(SETUP_NAME) $(ARGS)
	@echo

Configurer le fichier de variables d'environnement

Ajouter le fichier > build-cmd/envs.sh

Ouvrir le terminal dans VSCode

View > Terminal

Rendre exécutable les fichiers de script

chmod a+x makes.sh
chmod a+x envs.sh

Exécuter le projet

./makes.sh all

Configurer la version WSL-v2

wsl -l -v
...
  NAME              STATE           VERSION
* Ubuntu            Stopped         1
  docker-desktop    Stopped         2
...
wsl --set-version Ubuntu 2
...
wsl -l -v
...
  NAME              STATE           VERSION
* Ubuntu            Running         2
  docker-desktop    Stopped         2

Récupérer l'emplacement du répertoire include

Ouvrir l'explorateur Windows
Explorer > Linux > Ubuntu
...
Ouvrir le dossier > include
Récupérer le chemin du dossier dans la barre d'adresse
\\wsl.localhost\Ubuntu\home\admins\Qt5.14.2\5.14.2\gcc_64\include
...
Adapter le chemin du dossier
/home/admins/Qt5.14.2/5.14.2/gcc_64/include 

Créer le fichier de configurations C/C++

Barre de recherche > Show and Run Commands
> C/C++: Edit Configurations (JSON)

Configurer les répertoires include

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**",
                "/home/admins/Qt5.14.2/5.14.2/gcc_64/include",
                "/home/admins/Qt5.14.2/5.14.2/gcc_64/include/QtCore",
                "/home/admins/Qt5.14.2/5.14.2/gcc_64/include/QtWidgets"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/g++",
            "cStandard": "gnu17",
            "cppStandard": "gnu++17",
            "intelliSenseMode": "linux-gcc-x64"
        }
    ],
    "version": 4
}

Configurer le projet Qt sous CMake

cmake_minimum_required(VERSION 3.5.0)
project(ReadyScope VERSION 0.1.0 LANGUAGES C CXX)
...
find_package(Qt5 REQUIRED COMPONENTS
Widgets
)
...
add_executable(ReadyScope
main.cpp
)
...
target_link_libraries (ReadyScope
Qt5::Widgets
)

#include <QApplication>
#include <QDebug>
...
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    qDebug() << "Démarrage de l'application...";
    return a.exec();
}

Exécuter le projet

./makes.sh all

Configurer le fichier ressource Qt

<RCC>
    <qresource prefix="/">
        <file>data/img/app-logo.ico</file>
    </qresource>
</RCC>

Configurer le logo de l'application

Ajouter le fichier > data/img/app-logo.ico

Ouvrir l'outil Qt Designer

/home/admins/Qt5.14.2/5.14.2/gcc_64/bin/designer

Créer l'interface utilisateur (ui)

File > New > Main Window > Create
...
File > Save As
Lock In > v03
File name > MainWindow.ui
Save

Ajouter une ressource Qt à l'interface utilisateur (ui)

Resource Browser > Edit Resources > Open Resource File 
Look In > v03
File name > resources.qrc > Open
OK

Configurer les propriétés de l'interface utilisateur (ui)

QMainWindow > Property > objectName > MainWindow
QMainWindow > Property > windowTitle > ReadyScope - Oscilloscope numérique
QMainWindow > Property > windowIcon > Choose Resource > app-logo.ico > OK

Configurer l'interface utilisateur (ui)

#include <QApplication>
#include <QStyleFactory>
#include <QDebug>
...
#include "MainWindow.h"
...
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    qDebug() << "Démarrage de l'application...";
    ...
    MainWindow w;
    w.show();
    ...
    return a.exec();
}

#pragma once
...
#include <QMainWindow>
...
namespace Ui
{
    class MainWindow;
}
...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
    ...
private:
    Ui::MainWindow *ui;
};

#include "MainWindow.h"
#include "ui_MainWindow.h"
...
#include <QDebug>
...
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow)
{
    ui->setupUi(this);
}
...
MainWindow::~MainWindow()
{
    delete ui;
}

cmake_minimum_required(VERSION 3.5.0)
project(ReadyScope VERSION 0.1.0 LANGUAGES C CXX)
...
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
...
find_package(Qt5 REQUIRED COMPONENTS
Widgets
)
...
set(SRC_FILES
main.cpp
)
...
set(UI_FILES
MainWindow.cpp
)
...
set(RCC_FILES
resources.qrc
)
...
add_definitions(-DDEVELMODE)
...
qt_wrap_ui(${UI_FILES})
...
add_executable(ReadyScope
${SRC_FILES}
${UI_FILES}
${RCC_FILES}
)
...
target_link_libraries (ReadyScope
Qt5::Widgets
)

Exécuter le projet

./makes.sh all
...
L'application est lancée
...
L'icône de l'application apparaît dans la barre des tâches

Configurer l'indicateur de définition

cmake_minimum_required(VERSION 3.5.0)
project(ReadyScope VERSION 0.1.0 LANGUAGES C CXX)
...
add_definitions(-DDEVELMODE)
...

...
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    ...
#ifdef DEVELMODE
    qDebug() << "Démarrage de l'application [WITH_DEVEL_MODE]...";
#else
    qDebug() << "Démarrage de l'application [NO_DEVEL_MODE]...";
#endif
}
...

Exécuter le projet

./makes.sh all
...
L'indicateur de définition (DEVELMODE) est bien pris en compte
...
Le bon message apparaît à l'écran

Créer l'interface utilisateur (ui)

QStackedWidget > Property > objectName > stackedWidget
QTabWidget > Property > objectName > tabWidget
QVBoxLayout > Property > layoutName > layScope

Initialiser le fond d'écran de l'oscilloscope

...
namespace Ui
{
    class MainWindow;
}
...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
public:
    explicit MainWindow(QWidget *parent = nullptr);
    ...
private:
    Ui::MainWindow *ui;
    DScopesQTWidget *dscopes;
};
...

...
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow),
      ...
{
    ui->setupUi(this);
    ...
    ui->stackedWidget->setCurrentIndex(0);
    ui->tabWidget->setCurrentIndex(0);
    dscopes = new DScopesQTWidget(0, 0, 640, 480, false);
    ui->layScope->addWidget(dscopes);
    ...
    resize(800, 640);
}
...

...
class DScopesQTWidget : public QWidget, public DScopesQT
{
    Q_OBJECT
    ...
public:
    DScopesQTWidget(unsigned _x, unsigned _y, unsigned _w, unsigned _h, bool 
    _alpha = false, unsigned scale = 1, QWidget *parent = 0);
    ~DScopesQTWidget();
    ...
protected:
    void paintEvent(QPaintEvent *event);
    void resizeEvent(QResizeEvent *event);
    ...
private:
    QImage pixmap;
    unsigned basex, basey;
    unsigned scale;
};
...

...
DScopesQTWidget::DScopesQTWidget(unsigned _x, unsigned _y, unsigned _w, unsigned _h, bool _alpha, unsigned _scale, QWidget *parent)
    : QWidget(parent),
      DScopesQT(&pixmap, _w / _scale, _h / _scale, _alpha),
      pixmap(_w / _scale, _h / _scale, format),
      basex(_x),
      basey(_y),
      scale(_scale)
{
    setMinimumSize(QSize(320, 200));
    setCursor(QCursor(Qt::CrossCursor));
    QPainter painter;
    painter.begin(&pixmap);
    painter.fillRect(_x, _y, w, h, Qt::black);
    painter.end();
    ...
}
...
void DScopesQTWidget::paintEvent(QPaintEvent *event)
{
    QPainter p(this);
    QRect validRect = rect() & event->rect();
    p.setClipRect(validRect);
    p.drawImage(basex, basey, surface->scaled(surface->width() * scale, surface->height() * scale));
}
...
void DScopesQTWidget::resizeEvent(QResizeEvent *event)
{
    pixmap = pixmap.scaled(QSize(event->size().width() / scale, event->size().height() / scale));
}
...

...
class DScopesQT : public Scopes
{
public:
    DScopesQT(QImage *s, unsigned _w, unsigned _h, bool _alpha = false);
    ...
protected:
    QImage *surface;
};
...

...
DScopesQT::DScopesQT(QImage *s, unsigned _w, unsigned _h, bool _alpha)
    : Scopes(_w, _h)
{
    surface = s;
} 
...

...
class Scopes
{
public:
    Scopes(unsigned _w, unsigned _h);
    ...
protected:
    unsigned w, h;
};
...

...
Scopes::Scopes(unsigned _w, unsigned _h)
    : w(_w),
      h(_h)
{
}
...

...
set(SRC_FILES
...
scope/Scopes.cpp
scope/DScopesQT.cpp
scope/DScopesQTWidget.cpp
)
...
include_directories(
scope
)
...

Exécuter le projet

./makes.sh all
...
La fenêtre princiaple de l'application apparaît
...
L'oscilloscope apparaît avec un fond d'écran noir

Créer l'interface utilisateur (ui)

QSpinBox > Property > objectName > edtRefreshRate
QSpinBox > Property > value > 10
QSpinBox > Property > minimum > 1
QSpinBox > Property > maximum > 60

Configurer la connexion automatique

...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
private slots:
    void on_edtRefreshRate_valueChanged(int i);
    ...
};

...
void MainWindow::on_edtRefreshRate_valueChanged(int i)
{
    qDebug() << "MainWindow::on_edtRefreshRate_valueChanged...";
}
...

Exécuter le projet

./makes.sh all
...
La fenêtre princiaple de l'application apparaît
...
Cliquer sur l'onglet (Config)
...
Modifier le taux de rafraîchissement de l'oscilloscope
Modifier le taux de rafraîchissement de l'oscilloscope
Modifier le taux de rafraîchissement de l'oscilloscope
...
Le slot connecté au changement du taux de rafraîchissement est appelé
Le slot connecté au changement du taux de rafraîchissement est appelé
Le slot connecté au changement du taux de rafraîchissement est appelé

...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
public:
    explicit MainWindow(QWidget *parent = nullptr);
    ...
private:
    bool loadSettings(const QString &fileName = "");
    ...
};

...
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    ...
    loadSettings();
}
...
bool MainWindow::loadSettings(const QString &fileName)
{
    QSettings *settings;
    ...
    if (fileName == "")
        settings = new QSettings(QSettings::IniFormat, QSettings::UserScope, 
        "ReadyDev", "ReadyScope");
    else
        settings = new QSettings(fileName, QSettings::IniFormat);
    ...
    if (settings->status() != QSettings::NoError)
        return false;
    ...
    int refreshRate = settings->value("RefreshRate", 10).toInt();
    ...
    if (refreshRate < ui->edtRefreshRate->minimum())
        refreshRate = ui->edtRefreshRate->minimum();
    if (refreshRate > ui->edtRefreshRate->maximum())
        refreshRate = ui->edtRefreshRate->maximum();
    ...
    ui->edtRefreshRate->setValue(refreshRate);
    on_edtRefreshRate_valueChanged(refreshRate);
    ...
    delete settings;
    return true;
}
...

Configurer la sauvegarde

...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
public:
    ~MainWindow();
    ...
private:
    bool saveSettings(const QString &fileName = "");
    ...
};

...
MainWindow::~MainWindow()
{
    saveSettings();
    delete ui;
}
...
bool MainWindow::saveSettings(const QString &fileName)
{
    QSettings *settings;
    ...
    if (fileName == "")
        settings = new QSettings(QSettings::IniFormat, QSettings::UserScope, 
        "ReadyDev", "ReadyScope");
    else
        settings = new QSettings(fileName, QSettings::IniFormat);
    ...
    if (settings->status() != QSettings::NoError)
        return false;
    ...
    settings->setValue("RefreshRate", ui->edtRefreshRate->value());
    ...
    delete settings;
    return true;
}
...

Exécuter le projet

./makes.sh all
...
La fenêtre princiaple de l'application apparaît
...
Fermer l'application
...
Le fichier (settings.ini) est créé
Les paramètres de l'application sont bien enregistrés

[General]
RefreshRate=15

Configurer le timer

...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
public:
    explicit MainWindow(QWidget *parent = nullptr);
    ...
protected:
    void timerEvent(QTimerEvent *event);
    ...
private:
    bool loadSettings(const QString &fileName = "");
    ...
private slots:
    void on_edtRefreshRate_valueChanged(int i);
    ...
private:
    Ui::MainWindow *ui;
    int timer;
    ...
};

...
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow),
      timer(0)
{
    ui->setupUi(this);
    ...
    loadSettings();
}
...
void MainWindow::timerEvent(QTimerEvent *event)
{
    qDebug() << "MainWindow::timerEvent...";
}
...
bool MainWindow::loadSettings(const QString &fileName)
{
    ...
    on_edtRefreshRate_valueChanged(refreshRate);
    ...
    return true;
}
...
void MainWindow::on_edtRefreshRate_valueChanged(int i)
{
    if (timer)
    {
        killTimer(timer);
        timer = 0;
    }
    timer = startTimer(1000 / i);
}
...

Exécuter le projet

./makes.sh all
...
La fenêtre princiaple de l'application apparaît
...
Le timer associé à la fenêtre principale est bien en marche

Créer le gestionnaire de sauvegarde

...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
public:
    ~MainWindow();
    ...
private:
    bool saveSettings(const QString &fileName = "");
    ...
};

...
MainWindow::~MainWindow()
{
    saveSettings("settings.ini");
    delete ui;
}
...
bool MainWindow::saveSettings(const QString &fileName)
{
    if (fileName == "")
        return false;
    ...
    DSettings *settings;
    settings = new DSettings(fileName);
    ...
    if (settings->status() != QSettings::NoError)
        return false;
    ...
    settings->setValue("RefreshRate", ui->edtRefreshRate->value());
    ...
    delete settings;
    return true;
}
...

...
class DSettings : public QObject
{
    Q_OBJECT
    ...
public:
    explicit DSettings(const QString &fileName, QObject *parent = nullptr);
    ~DSettings();
    QSettings::Status status() const;
    QString escape(const QString &str);
    void setValue(const QString &key, const QString &value);
    void setValue(const QString &key, int value);
    ...
private:
    QFile file;
    QTextStream outstream;
};
...

...
DSettings::DSettings(const QString &fileName, QObject *parent)
    : QObject(parent)
{
    if (fileName.isNull())
        return;
    ...
    file.setFileName(fileName);
    ...
    if (file.open(QIODevice::WriteOnly | QIODevice::Text | 
    QIODevice::Truncate))
    {
        outstream.setDevice(&file);
        outstream << "[General]" << Qt::endl;
    }
}
...
DSettings::~DSettings()
{
    if (file.isOpen())
    {
        file.close();
    }
}
...
QSettings::Status DSettings::status() const
{
    if (file.isOpen())
        return QSettings::NoError;
    else
        return QSettings::AccessError;
}
...
QString DSettings::escape(const QString &str)
{
    if (str.indexOf("\n") == -1 && str.indexOf("\a") == -1 && 
    str.indexOf(";") == -1)
        return str;

    QString escaped(str);
    escaped = escaped.replace("\n", "\\n");
    escaped = escaped.replace("\a", "\\a");
    return "\"" + escaped + "\"";
}
...
void DSettings::setValue(const QString &key, const QString &value)
{
    outstream << key << "=" << escape(value) << Qt::endl;
}
...
void DSettings::setValue(const QString &key, int value)
{
    setValue(key, QString("%1").arg(value));
}
...

...
set(SRC_FILES
...
DSettings.cpp
)
...

Exécuter le projet

./makes.sh all
...
La fenêtre princiaple de l'application apparaît
...
Fermer l'application
...
Le fichier (settings.ini) est créé
Les paramètres de l'application sont bien enregistrés

[General]
RefreshRate=10

Lire les arguments

...
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow),
      timer(0)
{
    ui->setupUi(this);
    ...
    QStringList arg = qApp->arguments();
    qDebug() << arg;
}
...

Exécuter le projet

./makes.sh all
...
La fenêtre princiaple de l'application apparaît
...
Les arguments passés en ligne de commande sont affichés

Créer la page (0)

QStackedWidget > Property > objectName > stackedWidget
...
QWidget > Property > objectName > page_0

Créer la page (1)

QStackedWidget > Property > objectName > stackedWidget
...
QWidget > Property > objectName > page_1

Naviguer entre les pages

...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
public:
    explicit MainWindow(QWidget *parent = nullptr);
    ...
private slots:
    void on_btnPreviousPage_clicked();
    void on_btnNextPage_clicked();
    ...
};

...
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow),
      timer(0)
{
    ui->setupUi(this);
    ...
}
...
void MainWindow::on_btnPreviousPage_clicked()
{
    int current = ui->stackedWidget->currentIndex();
    if (current <= 0)
        return;
    ui->stackedWidget->setCurrentIndex(current - 1);
}
...
void MainWindow::on_btnNextPage_clicked()
{
    int current = ui->stackedWidget->currentIndex();
    if (current >= ui->stackedWidget->count() - 1)
        return;
    ui->stackedWidget->setCurrentIndex(current + 1);
}
...

Exécuter le projet

./makes.sh all
...
La fenêtre princiaple de l'application apparaît
...
Cliquer sur le bouton (Previous page)
...
La page (0) apparaît dans la fenêtre principale

Cliquer sur le bouton (Next page)
...
La page (1) apparaît dans la fenêtre principale

Installer la librairie Qt Serial Port

apt-cache search serial | grep qt
...
libqt5serialport5-dev - Qt 5 serial port development files
...
sudo apt install libqt5serialport5-dev

Installer le gestionnaire de port série virtuel

sudo apt install socat

Créer un port série virtuel

socat -d -d pty,raw,echo=0 pty,raw,echo=0
...
2024/12/07 12:01:32 socat[335058] N PTY is /dev/pts/11
2024/12/07 12:01:32 socat[335058] N PTY is /dev/pts/12
2024/12/07 12:01:32 socat[335058] N starting data transfer loop with FDs [5,5] and [7,7]
...

Se connecter au port série virtuel

QPushButton > Property > objectName > btnConnect
QPushButton > Property > text > &Connect
...
QLineEdit > Property > objectName > edtHostPort
...

...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
public:
    explicit MainWindow(QWidget *parent = nullptr);
    ...
protected:
    void timerEvent(QTimerEvent *event);
    ...
private slots:
    void on_btnConnect_clicked();
    void iodevread(QByteArray ba);
    void ioconnected();
    void ioerror(QString err);
    void ioconnectionerror();
    ...
private:
    Ui::MainWindow *ui;
    DScopesQTWidget *dscopes;
    IoDevice iodev;
    ...
};

...
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow),
{
    ui->setupUi(this);
    ...
    connect(&iodev, SIGNAL(readyRead(QByteArray)), this, SLOT(iodevread(QByteArray)));
    connect(&iodev, SIGNAL(connected()), this, SLOT(ioconnected()));
    connect(&iodev, SIGNAL(error(QString)), this, SLOT(ioerror(QString)));
    connect(&iodev, SIGNAL(connectionError()), this, SLOT(ioconnectionerror()));
    ...
}
...
void MainWindow::timerEvent(QTimerEvent *event)
{
    dscopes->Render();
    dscopes->repaint();
}
...
void MainWindow::iodevread(QByteArray ba)
{
    qDebug() << "MainWindow::iodevread...";
}
...
void MainWindow::ioconnected()
{
    qDebug() << "MainWindow::ioconnected...";
}
...
void MainWindow::ioerror(QString err)
{
    QMessageBox::critical(this, "ReadyScope - Error", QString("I/O error: %1").arg(err));
}
...
void MainWindow::ioconnectionerror()
{
    QMessageBox::critical(this, "ReadyScope - Error", "Connection error");
}
...
void MainWindow::on_btnConnect_clicked()
{
    ConnectionData conn;
    ...
    bool ok = ParseConnection(ui->edtHostPort->text(), conn);
    ...
    if (!ok)
    {
        QMessageBox::critical(this, "ReadyScope - Device specification error", conn.message);
        return;
    }
    ...
    iodev.open(conn);
}
...

...
bool ParseConnection(QString str, ConnectionData &conn);

...
bool ParseConnection(QString str, ConnectionData &conn)
{
    str = str.toUpper();
    QStringList parts = str.split(':');
    ...
    for (int i = 0; i < parts.size(); i++)
        parts[i] = parts[i].trimmed();
    ...
    if (parts[0] != "SER" && parts[0] != "TCP" && parts[0] != "BT")
    {
        conn.message = "Invalid connection string: the format is <BT|SER|TCP>:<param>[:<param>]";
        return false;
    }
    ...
    if (parts[0] == "BT")
    {
    }
    else if (parts[0] == "SER")
    {
        conn.port = "/dev/pts/11";
        conn.baud = QSerialPort::Baud4800;
        conn.type = DevSerialConnection;
        return true;
    }
    else if (parts[0] == "TCP")
    {
    }
    ...
    return false;
}

...
typedef enum _connect_t
{
    DevNotConnected,
    DevTCPConnection,
    DevSerialConnection,
    DevBTConnection
} connect_t;
...
typedef struct _ConnectionData
{
    connect_t type;
    QString message;
    QString port;
    QSerialPort::BaudRate baud;
} ConnectionData;
...
class IoDevice : public QObject
{
    Q_OBJECT
    ...
public:
    explicit IoDevice(QObject *parent = nullptr);
    ~IoDevice();
    ...
    bool open(ConnectionData cd);
    bool close(void);
    ...
private slots:
    void SERGotData();
    void SERError(QSerialPort::SerialPortError err);
    ...
signals:
    void readyRead(QByteArray b);
    void connected();
    void disconnected();
    void error(QString errmsg);
    void connectionError();
    ...
private:
    ConnectionData connectiondata;
    QSerialPort deviceSER;
    ...
};

...
IoDevice::IoDevice(QObject *parent)
    : QObject(parent),
      deviceSER(parent)
{
    connect(&deviceSER, SIGNAL(readyRead()), this, SLOT(SERGotData()));
    connect(&deviceSER, SIGNAL(errorOccurred(QSerialPort::SerialPortError)), this, SLOT(SERError(QSerialPort::SerialPortError)));
    ...
}
...
IoDevice::~IoDevice()
{
}
...
bool IoDevice::open(ConnectionData cd)
{
    ...
    connectiondata = cd;
    ...
    switch (cd.type)
    {
    case DevTCPConnection:
        ...
        break;
    case DevSerialConnection:
        deviceSER.setPortName(cd.port);
        deviceSER.setDataBits(QSerialPort::Data8);
        deviceSER.setFlowControl(QSerialPort::NoFlowControl);
        deviceSER.setParity(QSerialPort::NoParity);
        deviceSER.setStopBits(QSerialPort::OneStop);
        ...
        deviceSER.open(QIODevice::ReadWrite);
        ...
        if (!deviceSER.isOpen())
        {
            qDebug("IoDevice: Serial: cannot open. Check port:speed settings.\n");
            emit connectionError();
            return false;
        }
        else
        {
            qDebug("IoDevice: Serial: Open successful\n");
            emit connected();
            return true;
        }
        ...
        break;
    case DevBTConnection:
        ...
        break;
    case DevNotConnected:
        break;
    }
    return true;
}
...
void IoDevice::SERGotData()
{
    qDebug() << "IoDevice::SERGotData...";
}
...
void IoDevice::SERError(QSerialPort::SerialPortError err)
{
    if (err == QSerialPort::NoError)
    {
        return;
    }
    ...
    QString str = QString("IoDevice: serial error %1").arg(err);
    emit error(str);
    close();
}
...

Exécuter le projet

./makes.sh all
...
Cliquer sur le bouton (Next page) pour passer à la page de connexion
...
Saisir la valeur (SER) dans le champ (edtHostPort)
...
Cliquer sur le bouton (Connect)
...
L'application se connecte au port série (/dev/pts/11)
...
Le message ci-dessous apparaît
...
MainWindow::ioconnected...

Fermer le port série virtuel > Ctrl + C > dans le terminal
...
Saisir la valeur (SER) dans le champ (edtHostPort)
...
Cliquer sur le bouton (Connect)
...
La connexion au port série (/dev/pts/11) échoue
...
oDevice: Serial: cannot open. Check port:speed settings.
...
Cliquer sur le bouton > OK > OK

Démarrer le port série virtuel

socat -d -d pty,raw,echo=0 pty,raw,echo=0
...
2024/12/11 17:00:15 socat[397279] N PTY is /dev/pts/8
2024/12/11 17:00:15 socat[397279] N PTY is /dev/pts/9
2024/12/11 17:00:15 socat[397279] N starting data transfer loop with FDs [5,5] and [7,7]
...

Lire des données du port série virtuel

cat /dev/pts/8
...
Démarrage du port série...
Démarrage du port série...
Démarrage du port série...
...

Ecrire des données sur le port série virtuel

echo -ne "Démarrage du port série...\n\r" > /dev/pts/9
echo -ne "Démarrage du port série...\n\r" > /dev/pts/9
echo -ne "Démarrage du port série...\n\r" > /dev/pts/9

Configurer la lecture des données du port série virtuel

...
bool ParseConnection(QString str, ConnectionData &conn)
{
    ...
    else if (parts[0] == "SER")
    {
        conn.port = "/dev/pts/8";
        conn.baud = QSerialPort::Baud4800;
        conn.type = DevSerialConnection;
        return true;
    }
    ...
}
...

...
void IoDevice::SERGotData()
{
    QByteArray ba = deviceSER.readAll();
    emit readyRead(ba);
}
...

...
void MainWindow::iodevread(QByteArray ba)
{
    qDebug() << "MainWindow::iodevread..."
             << "|data=" << ba;
}
...

Exécuter le projet

./makes.sh all
...
Cliquer sur le bouton (Next page) pour passer à la page de connexion
...
Saisir la valeur (SER) dans le champ (edtHostPort)
...
Cliquer sur le bouton (Connect)
...
L'application se connecte au port série (/dev/pts/8)
...
Le message ci-dessous apparaît
...
MainWindow::ioconnected...
...
L'application attend des messages sur le port série (/dev/pts/8)

echo -ne "Demarrage du port serie..." > /dev/pts/9
echo -ne "Demarrage du port serie..." > /dev/pts/9
echo -ne "Demarrage du port serie..." > /dev/pts/9
...
L'application reçoit le message sur le port série (/dev/pts/8)
...
Le message ci-dessous apparaît
...
MainWindow::iodevread... |data= "Demarrage du port serie..."
MainWindow::iodevread... |data= "Demarrage du port serie..."
MainWindow::iodevread... |data= "Demarrage du port serie..."

Configurer le fichier (CMakeLists.txt)

Barre de recherche > Show and Run Commands
> CMake: Show Configure Command
Fichier > v03/CMakeLists.txt

Configurer le plugin Qt pour VSCode

cd $HOME
mkdir .qt-vscode
cd .qt-vscode/
...
wget https://raw.githubusercontent.com/KDE/kdevelop/master/plugins/gdb/printers/helper.py
...
wget https://raw.githubusercontent.com/KDE/kdevelop/master/plugins/gdb/printers/qt.py
...

Ouvrir le fichier (.gdbinit)

cd $HOME
touch .gdbinit
nano .gdbinit

Configurer le plugin Qt pour VSCode

python
...
import sys, os.path
sys.path.insert(0, os.path.expanduser("~/.qt-vscode"))
...
from qt import register_qt_printers
register_qt_printers (None)
...
end

Exécuter le débogueur

Placer des points d'arrêt aux lignes de débogage souhaitées
...
Démarrer le débogueur avec CMake sous VSCode
...
Placer le curseur sur une variable Qt
...
Le contenu de la variable Qt est afficher dans le débogueur

Calculer le temps écoulé en secondes

...
class PreciseTimer
{
public:
    static double QueryTimer();
}; 

...
double PreciseTimer::QueryTimer()
{
    timeval t1;
    double dt;
    ...
    gettimeofday(&t1, 0);
    ...
    dt = (((double)t1.tv_sec) + ((double)t1.tv_usec) / 1000000.0);
    ...
    qDebug("PreciseTimer::QueryTimer..."
           "|time=%f (sec)",
           dt);
    ...
    return dt;
}

...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
protected:
    void timerEvent(QTimerEvent *event);
    ...
};

...
void MainWindow::timerEvent(QTimerEvent *event)
{
    double f = 0.9;
    double t = PreciseTimer::QueryTimer();
    ...
}
...

Exécuter le projet

./makes.sh all
...
La fenêtre principale de l'application apparaît
...
Le temps écoulé depuis l'Epoch s'affiche en secondes

Calculer la fréquence de rafraichissement

...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
protected:
    void timerEvent(QTimerEvent *event);
    ...
Private:
    double time_displayed_last, time_displayed_delta;
    ...
};

...
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow),
      time_displayed_delta(0),
      ...
{
    ui->setupUi(this);
    ...
    time_displayed_last = PreciseTimer::QueryTimer();
    ...
}
...
void MainWindow::timerEvent(QTimerEvent *event)
{
    double f = 0.9;
    double t = PreciseTimer::QueryTimer();
    time_displayed_delta = f * time_displayed_delta + (1.0 - f) * (t - 
    time_displayed_last);
    time_displayed_last = t;
    ...
    qDebug("MainWindow::timerEvent..."
           "|Display rate: %3.0lf Hz",
           1.0 / time_displayed_delta);
    ...
}
...

Exécuter le projet

./makes.sh all
...
La fenêtre principale de l'application apparaît
...
La fréquence de rafraichissement de l'oscilloscope apparaît

Afficher la fréquence de rafraichissement

...
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
protected:
    void timerEvent(QTimerEvent *event);
    ...
Private:
    double time_displayed_last, time_displayed_delta;
    QLabel *displayrateLabel;
    ...
};

...
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow),
      time_displayed_delta(0),
      ...
{
    ui->setupUi(this);
    ...
    time_displayed_last = PreciseTimer::QueryTimer();
    ...
    displayrateLabel=new QLabel(statusBar());
    statusBar()->addWidget(displayrateLabel);
    ...
}
...
void MainWindow::timerEvent(QTimerEvent *event)
{
    double f = 0.9;
    double t = PreciseTimer::QueryTimer();
    time_displayed_delta = f * time_displayed_delta + (1.0 - f) * (t - 
    time_displayed_last);
    time_displayed_last = t;
    ...
    QString s;
    s = QString::asprintf("Display rate: %3.0lf Hz", 1.0 / 
    time_displayed_delta);
    displayrateLabel->setText(s);
    ...
}
...

Identifier la barre d'état de la fenêtre principale

QStatusBar > Property > objectName  > statusBar
...

Exécuter le projet

./makes.sh all
...
La fenêtre principale de l'application apparaît
...
La fréquence de rafraichissement de l'oscilloscope apparaît
dans la barre d'état de l'application