Terminal série

Terminal montre comment créer un terminal pour une interface série simple en utilisant la commande Qt Serial Port.

Cet exemple montre les principales caractéristiques de la classe QSerialPort, comme la configuration, l'implémentation des E/S, etc. En outre, la classe QSerialPortInfo est invoquée pour afficher des informations sur les ports série disponibles dans le système.

QSerialPort supporte deux approches générales de programmation :

• L'approche asynchrone (non bloquante). Les opérations sont programmées et exécutées lorsque le contrôle revient dans la boucle d'événements de Qt XML. QSerialPort émet un signal lorsque l'opération est terminée. Par exemple, QSerialPort::write() revient immédiatement. Lorsque les données sont envoyées au port série, QSerialPort émet bytesWritten().
• L'approche synchrone (bloquante). Dans les applications non-GUI et multithread, les fonctions waitFor...() peuvent être appelées (c'est-à-dire QSerialPort::waitForReadyRead()) pour suspendre le thread appelant jusqu'à ce que l'opération soit terminée.

Dans cet exemple, l'approche asynchrone est démontrée. L'exemple du récepteur bloquant illustre l'approche synchrone.

Notre exemple contient quelques widgets d'interface graphique :

• MainWindow (terminal/mainwindow.cpp) - c'est la fenêtre principale de l'application qui contient toute la logique de travail pour la programmation du port série, y compris la configuration, le traitement des E/S et ainsi de suite, tout en héritant de QMainWindow.
• Console (terminal/console.cpp) - est le widget central de la fenêtre principale, affichant les données transmises ou reçues. Le 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 MainWindow. Le widget principal est transmis en tant que parent, de sorte que la suppression de l'objet se produit automatiquement conformément au mécanisme parent et enfant de Qt Widgets :

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

Cet exemple illustre les signaux QSerialPort suivants :

• readyRead() - indique que de nouvelles données ont été reçues et sont donc disponibles
• bytesWritten() - utilisé pour vérifier que toutes les données ont été écrites avec succès

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

En cliquant sur le bouton Connect, on invoque 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 faite 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 Disconnect invoque la fente 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, il est géré par la fermeture du port série.

En cliquant sur le bouton Configurer, on invoque 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é, voir les informations sur le port sélectionné et définir les paramètres souhaités pour le port série donné.

Écriture de données

La saisie de caractères dans la console fait appel à l'emplacement 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 tapés dans le widget Console donné au port série - voir terminal/console.cpp. Il démarre également un minuteur pour vérifier si l'écriture a réussi ou non. Nous utilisons le signal bytesWritten() pour nous assurer que tous les octets ont bien été écrits. Il est connecté à l'emplacement 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é à l'emplacement MainWindow::readData():

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

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

Exécution de l'exemple

Pour exécuter l'exemple à partir de Qt Creatorouvrez le mode Welcome et sélectionnez l'exemple à partir de Examples. Pour plus d'informations, voir Qt Creator: Tutoriel : Construire et exécuter.

Exemple de projet @ code.qt.io