Terminal série

La section « Terminal » explique comment créer un terminal pour une interface série simple à l’aide de Qt Serial Port.

Cet exemple présente les principales fonctionnalités de la classe ` QSerialPort `, telles que la configuration, la mise en œuvre des E/S, etc. De plus, la classe ` QSerialPortInfo ` est appelée pour afficher des informations sur les ports série disponibles dans le système.

QSerialPort prend en charge deux approches de programmation générales :

• L'approche asynchrone (non bloquante). Les opérations sont planifiées et exécutées lorsque le contrôle revient à la boucle d'événements de Qt. La classe ` QSerialPort ` émet un signal lorsque l'opération est terminée. Par exemple, la fonction ` QSerialPort::write()` renvoie immédiatement un résultat. Lorsque les données sont envoyées vers le port série, la classe ` QSerialPort ` émet le signal ` bytesWritten()`.
• L'approche synchrone (bloquante). Dans les applications sans interface graphique et multithread, les fonctions de gestion des entrées/sorties ( waitFor...() ) peuvent être appelées (par exemple QSerialPort::waitForReadyRead()) pour suspendre le thread appelant jusqu'à ce que l'opération soit terminée.

Dans cet exemple, c’est l’approche asynchrone qui est présentée. L’exemple « Blocking Receiver » illustre l’approche synchrone.

Notre exemple contient quelques composants d’interface graphique :

• MainWindow (terminal/mainwindow.cpp) – il s'agit de la fenêtre principale de l'application qui contient toute la logique de fonctionnement pour la programmation du port série, y compris la configuration, le traitement des E/S, etc., tout en héritant de la classe QMainWindow.
• Console (terminal/console.cpp) : il s'agit du widget central de la fenêtre principale, qui affiche les données transmises ou reçues. Ce widget est dérivé de la classe QPlainTextEdit.
• SettingsDialog (terminal/settingsdialog.cpp) - est une boîte de dialogue permettant de configurer le port série, ainsi que d’afficher les ports série disponibles et les informations les concernant.

Le port série est instancié dans le constructeur de MainWindow. Le widget principal est passé en tant que parent, de sorte que la suppression de l’objet s’effectue automatiquement selon le mécanisme parent-enfant de Qt :

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    m_ui(new Ui::MainWindow),
    m_serial(new QSerialPort(this))
{
    ...

Cet exemple illustre les signaux suivants de QSerialPort:

• readyRead() - indique que de nouvelles données ont été reçues et sont donc disponibles
• bytesWritten() - permet de vérifier que toutes les données ont bien été écrites

    ...
    connect(m_serial, &QSerialPort::readyRead, this, &MainWindow::readData);
    connect(m_serial, &QSerialPort::bytesWritten, this, &MainWindow::handleBytesWritten);
    ...
}

Cliquer sur le bouton « Connect » déclenche le slot « openSerialPort() » :

void MainWindow::openSerialPort()
{
    const SettingsDialog::Settings p = m_settings->settings();
    m_serial->setPortName(p.name);
    m_serial->setBaudRate(p.baudRate);
    m_serial->setDataBits(p.dataBits);
    m_serial->setParity(p.parity);
    m_serial->setStopBits(p.stopBits);
    m_serial->setFlowControl(p.flowControl);
    if (m_serial->open(QIODevice::ReadWrite)) {
        m_console->setEnabled(true);
        m_console->setLocalEchoEnabled(p.localEchoEnabled);
        m_ui->actionConnect->setEnabled(false);
        m_ui->actionDisconnect->setEnabled(true);
        m_ui->actionConfigure->setEnabled(false);
        showStatusMessage(tr("Connected to %1 : %2, %3, %4, %5, %6")
                          .arg(p.name, p.stringBaudRate, p.stringDataBits,
                               p.stringParity, p.stringStopBits, p.stringFlowControl));
    } else {
        QMessageBox::critical(this, tr("Error"), m_serial->errorString());

        showStatusMessage(tr("Open error"));
    }
}

Dans ce slot, les paramètres sont lus à partir de ` SettingsDialog ` et une tentative est effectuée pour ouvrir et initialiser le port série en conséquence. En cas de succès, la barre d’état affiche un message indiquant que l’ouverture a réussi avec la configuration donnée ; dans le cas contraire, une boîte de message s’affiche avec le code d’erreur et le message appropriés. Si les paramètres du port série n’ont jamais été appelés, le terminal tente d’ouvrir le port avec les paramètres par défaut : 9600 8N1.

Un clic sur le bouton « Déconnecter » déclenche l’événement « closeSerialPort() » :

void MainWindow::closeSerialPort()
{
    if (m_serial->isOpen())
        m_serial->close();
    m_console->setEnabled(false);
    m_ui->actionConnect->setEnabled(true);
    m_ui->actionDisconnect->setEnabled(false);
    m_ui->actionConfigure->setEnabled(true);
    showStatusMessage(tr("Disconnected"));
}

Dans ce cas, la fermeture du port série est gérée.

Cliquer sur le bouton « Configurer » déclenche le slot « show() » qui appartient au widget « SettingsDialog ».

Cette méthode (terminal/settingsdialog.cpp) affiche la fenêtre « SettingsDialog », dans laquelle l'utilisateur peut choisir le port série souhaité, consulter les informations relatives au port sélectionné et définir les paramètres souhaités pour ce port série.

Écriture de données

La saisie de caractères dans la console déclenche le slot « writeData() » :

void MainWindow::writeData(const QByteArray &data)
{
    const qint64 written = m_serial->write(data);
    if (written == data.size()) {
        m_bytesToWrite += written;
        m_timer->start(kWriteTimeout);
    } else {
        const QString error = tr("Failed to write all data to port %1.\n"
                                 "Error: %2").arg(m_serial->portName(),
                                                  m_serial->errorString());
        showWriteError(error);
    }
}

Ce slot envoie les caractères saisis dans le widget Console donné vers le port série — voir terminal/console.cpp. Il lance également un minuteur pour vérifier si l'écriture a bien abouti ou non. Nous utilisons le signal bytesWritten() pour nous assurer que tous les octets ont bien été écrits. Il est connecté au slot MainWindow::handleBytesWritten():

void MainWindow::handleBytesWritten(qint64 bytes)
{
    m_bytesToWrite -= bytes;
    if (m_bytesToWrite == 0)
        m_timer->stop();
}

Lecture des données

Lorsque le port série reçoit de nouvelles données, le signal readyRead() est émis, et ce signal est connecté au slot MainWindow::readData():

void MainWindow::readData()
{
    const QByteArray data = m_serial->readAll();
    m_console->putData(data);
}

Ce slot lit les données provenant du port série et les affiche dans le widget Console.

Exécution de l’exemple

Vous pouvez exécuter l’exemple à partir de :

• Qt Creator

  Ouvrez le mode « Welcome » et sélectionnez l'exemple dans « Examples ». Pour plus d'informations, consultez Qt Creator: Tutoriel : Compiler et exécuter.

• Qt Extension for Visual Studio Code

  Exécutez la commande « Qt: Open Qt examples » à partir de Command Palette, puis sélectionnez l’exemple dans la liste. Pour plus d’informations, consultez Qt Extension for Visual Studio Code: Tutoriel : Compiler et exécuter.

Exemple de projet sur code.qt.io