QSerialPort Class

qint64 numReadTotal = 0;
char buffer[50];

for (;;) {
    const qint64 numRead  = serial.read(buffer, 50);

    // Do whatever with the array

    numReadTotal += numRead;
    if (numRead == 0 && !serial.waitForReadyRead())
        break;
}

Member Function Documentation

[explicit] QSerialPort::QSerialPort(QObject *parent = nullptr)

Construit un nouvel objet port série avec l'adresse parent.

[explicit] QSerialPort::QSerialPort(const QSerialPortInfo &serialPortInfo, QObject *parent = nullptr)

Construit un nouvel objet port série avec l'adresse parent pour représenter le port série avec la classe d'aide spécifiée serialPortInfo.

[explicit] QSerialPort::QSerialPort(const QString &name, QObject *parent = nullptr)

Construit un nouvel objet port série avec le nom parent donné pour représenter le port série avec le nom name spécifié.

Le nom doit avoir un format spécifique ; voir la méthode setPort().

[virtual noexcept] QSerialPort::~QSerialPort()

Ferme le port série, si nécessaire, puis détruit l'objet.

[signal] void QSerialPort::baudRateChanged(qint32 baudRate, QSerialPort::Directions directions)

Ce signal est émis lorsque le débit en bauds a été modifié. La nouvelle vitesse de transmission est transmise en tant que baudRate et les directions en tant que directions.

Voir aussi QSerialPort::baudRate.

[override virtual] qint64 QSerialPort::bytesAvailable() const

Réimplémente : QIODevice::bytesAvailable() const.

Renvoie le nombre d'octets entrants en attente de lecture.

Voir aussi bytesToWrite() et read().

[override virtual] qint64 QSerialPort::bytesToWrite() const

Réimplémente : QIODevice::bytesToWrite() const.

Renvoie le nombre d'octets en attente d'écriture. Les octets sont écrits lorsque le contrôle revient à la boucle d'événements ou lorsque flush() est appelé.

Voir aussi bytesAvailable() et flush().

[override virtual] bool QSerialPort::canReadLine() const

Réimplémente : QIODevice::canReadLine() const.

Renvoie true si une ligne de données peut être lue sur le port série ; sinon, renvoie false.

Voir également readLine().

bool QSerialPort::clear(QSerialPort::Directions directions = AllDirections)

Rejette tous les caractères de la mémoire tampon de sortie ou d'entrée, en fonction des instructions données directions. Cela inclut l'effacement des tampons de classe internes et des tampons UART (pilote). Termine également les opérations de lecture ou d'écriture en cours. En cas de succès, la commande renvoie true; sinon, elle renvoie false.

[override virtual] void QSerialPort::close()

Réimplémente : QIODevice::close().

Voir aussi QIODevice::close().

[signal] void QSerialPort::dataBitsChanged(QSerialPort::DataBits dataBits)

Ce signal est émis lorsque les bits de données d'une trame ont été modifiés. Les nouveaux bits de données d'une trame sont transmis en tant que dataBits.

Voir également QSerialPort::dataBits.

[signal] void QSerialPort::dataTerminalReadyChanged(bool set)

Ce signal est émis après que l'état (haut ou bas) du signal de ligne DTR a été modifié. Le nouvel état (haut ou bas) du signal de ligne DTR est transmis à set.

Voir également QSerialPort::dataTerminalReady.

[signal] void QSerialPort::errorOccurred(QSerialPort::SerialPortError error)

Ce signal est émis lorsqu'une erreur se produit sur le port série. L'adresse error spécifiée décrit le type d'erreur qui s'est produite.

Voir également QSerialPort::error.

[signal] void QSerialPort::flowControlChanged(QSerialPort::FlowControl flow)

Ce signal est émis lorsque le mode de contrôle du flux a été modifié. Le nouveau mode de contrôle de flux est transmis en tant que flow.

Voir également QSerialPort::flowControl.

bool QSerialPort::flush()

Cette fonction écrit autant de données que possible depuis le tampon d'écriture interne vers le port série sous-jacent sans bloquer. Si des données ont été écrites, cette fonction renvoie true; sinon, elle renvoie false.

Appelez cette fonction pour envoyer immédiatement les données mises en mémoire tampon au port série. Le nombre d'octets écrits avec succès dépend du système d'exploitation. Dans la plupart des cas, il n'est pas nécessaire d'appeler cette fonction, car la classe QSerialPort commence à envoyer les données automatiquement dès que le contrôle est renvoyé à la boucle d'événements. En l'absence d'une boucle d'événements, appelez plutôt waitForBytesWritten().

Voir également write() et waitForBytesWritten().

QSerialPort::Handle QSerialPort::handle() const

Si la plate-forme est prise en charge et que le port série est ouvert, renvoie la poignée native du port série ; sinon, renvoie -1.

[override virtual] bool QSerialPort::isSequential() const

Réimplémente : QIODevice::isSequential() const.

Renvoie toujours true. Le port série est un dispositif séquentiel.

[override virtual] bool QSerialPort::open(QIODeviceBase::OpenMode mode)

Réimplémente : QIODevice::open(QIODeviceBase::OpenMode mode).

Ouvre le port série à l'aide de l'OpenMode mode, puis renvoie true en cas de succès ; dans le cas contraire, renvoie false et définit un code d'erreur qui peut être obtenu en appelant la méthode error().

Si le port est ouvert, mais que la définition des paramètres de port souhaités échoue, la méthode renvoie false et ferme le port automatiquement.

Voir aussi QIODeviceBase::OpenMode et setPort().

[signal] void QSerialPort::parityChanged(QSerialPort::Parity parity)

Ce signal est émis lorsque le mode de contrôle de la parité a été modifié. Le nouveau mode de contrôle de la parité est transmis en tant que parity.

Voir aussi QSerialPort::parity.

QSerialPort::PinoutSignals QSerialPort::pinoutSignals()

Renvoie l'état des signaux de ligne dans un format bitmap.

À partir de ce résultat, il est possible d'attribuer l'état du signal souhaité en appliquant un masque "AND", où le masque est la valeur d'énumération souhaitée à partir de QSerialPort::PinoutSignals.

Voir également QSerialPort::dataTerminalReady et QSerialPort::requestToSend.

QString QSerialPort::portName() const

Renvoie le nom défini par setPort() ou transmis au constructeur de QSerialPort. Ce nom est court, c'est-à-dire qu'il est extrait et converti à partir de l'emplacement du système de variables internes de l'appareil. L'algorithme de conversion est spécifique à chaque plate-forme :

Voir également setPortName(), setPort() et QSerialPortInfo::portName().

qint64 QSerialPort::readBufferSize() const

Renvoie la taille du tampon de lecture interne. Cela limite la quantité de données que le client peut recevoir avant d'appeler les méthodes read() ou readAll().

Une taille de tampon de lecture de 0 (par défaut) signifie que le tampon n'a pas de limite de taille, ce qui garantit qu'aucune donnée n'est perdue.

Voir également setReadBufferSize() et read().

[override virtual protected] qint64 QSerialPort::readData(char *data, qint64 maxSize)

Réimplémente : QIODevice::readData(char *data, qint64 maxSize).

[override virtual protected] qint64 QSerialPort::readLineData(char *data, qint64 maxSize)

Réimplémente : QIODevice::readLineData(char *data, qint64 maxSize).

[signal] void QSerialPort::requestToSendChanged(bool set)

Ce signal est émis après que l'état (haut ou bas) du signal de ligne RTS a été modifié. Le nouvel état (haut ou bas) du signal de ligne RTS est transmis en tant que set.

Voir également QSerialPort::requestToSend.

void QSerialPort::setPort(const QSerialPortInfo &serialPortInfo)

Définit le port stocké dans l'instance d'information sur le port série serialPortInfo.

Voir aussi portName() et QSerialPortInfo.

void QSerialPort::setPortName(const QString &name)

Définit l'adresse name du port série.

Le nom du port série peut être transmis sous la forme d'un nom court ou d'un emplacement système long si nécessaire.

Voir également portName() et QSerialPortInfo.

void QSerialPort::setReadBufferSize(qint64 size)

Fixe la taille du tampon de lecture interne de QSerialPort à size octets.

Si la taille de la mémoire tampon est limitée à une certaine taille, QSerialPort ne mettra pas en mémoire tampon plus de données que cette taille. Le cas particulier d'une taille de tampon de 0 signifie que le tampon de lecture est illimité et que toutes les données entrantes sont mises en mémoire tampon. Il s'agit de la valeur par défaut.

Cette option est utile si les données ne sont lues qu'à certains moments (par exemple dans une application de flux en temps réel) ou si le port série doit être protégé contre la réception d'un trop grand nombre de données, ce qui pourrait éventuellement entraîner une saturation de la mémoire de l'application.

Voir aussi readBufferSize() et read().

[since 6.10] void QSerialPort::setWriteBufferSize(qint64 size)

Fixe la taille du tampon d'écriture interne de QSerialPort à size octets.

L'envoi des données sur le port série est relativement lent, c'est pourquoi, en pratique, lorsque write() est appelé, les données ne sont pas envoyées immédiatement. Elles sont d'abord stockées dans un tampon intermédiaire, puis écrites par morceaux.

Ainsi, une tentative d'écrire trop de données ou d'écrire des données à un taux plus élevé que ce que le port série sous-jacent peut gérer, peut conduire à une situation où le tampon interne va croître. L'application peut alors se retrouver à court de mémoire, en particulier sur un appareil disposant de peu de ressources mémoire.

Cette méthode permet de limiter la mémoire tampon interne à une certaine taille. Si la prochaine tentative d'écriture dépasse la capacité de la mémoire tampon, la méthode write() renvoie le nombre d'octets réellement stockés dans la mémoire tampon. Il incombe à l'utilisateur de répéter la tentative d'écriture avec le reste des octets après la réception du signal bytesWritten() ou après que la méthode waitForBytesWritten() a renvoyé true.

Passer 0 à cette méthode signifie que le tampon d'entrée n'est pas limité et que toutes les données entrantes sont mises en mémoire tampon. Il s'agit de la valeur par défaut.

Cette fonction a été introduite dans Qt 6.10.

Voir aussi writeBufferSize() et write().

[signal, since 6.9] void QSerialPort::settingsRestoredOnCloseChanged(bool restore)

Ce signal est émis lorsque la propriété settingsRestoredOnClose est modifiée. Le paramètre restore contient la nouvelle valeur de la propriété.

Cette fonction a été introduite dans Qt 6.9.

Voir aussi QSerialPort::settingsRestoredOnClose.

[signal] void QSerialPort::stopBitsChanged(QSerialPort::StopBits stopBits)

Ce signal est émis lorsque le nombre de bits d'arrêt d'une trame a été modifié. Le nouveau nombre de bits d'arrêt dans une trame est transmis en tant que stopBits.

Voir également QSerialPort::stopBits.

[override virtual] bool QSerialPort::waitForBytesWritten(int msecs = 30000)

Réimplémente : QIODevice::waitForBytesWritten(int msecs).

Cette fonction se bloque jusqu'à ce qu'au moins un octet ait été écrit sur le port série et que le signal bytesWritten() ait été émis. La fonction s'arrête au bout de msecs millisecondes ; le délai par défaut est de 30000 millisecondes. Si msecs vaut -1, cette fonction ne s'arrêtera pas.

La fonction renvoie true si le signal bytesWritten() est émis ; sinon, elle renvoie false (si une erreur s'est produite ou si l'opération s'est arrêtée).

[override virtual] bool QSerialPort::waitForReadyRead(int msecs = 30000)

Réimplémente : QIODevice::waitForReadyRead(int msecs).

Cette fonction se bloque jusqu'à ce que de nouvelles données soient disponibles pour la lecture et que le signal readyRead() ait été émis. La fonction s'arrête au bout de msecs millisecondes ; le délai par défaut est de 30000 millisecondes. Si msecs vaut -1, cette fonction ne s'arrêtera pas.

La fonction renvoie true si le signal readyRead() est émis et que de nouvelles données sont disponibles pour la lecture ; sinon, elle renvoie false (si une erreur s'est produite ou si l'opération s'est interrompue).

Voir aussi waitForBytesWritten().

[since 6.10] qint64 QSerialPort::writeBufferSize() const

Renvoie la taille du tampon d'écriture interne.

Une taille de tampon d'écriture de 0 (par défaut) signifie que le tampon n'a pas de limite de taille.

Cette fonction a été introduite dans Qt 6.10.

Voir aussi setWriteBufferSize() et write().

[override virtual protected] qint64 QSerialPort::writeData(const char *data, qint64 maxSize)

Réimplémente : QIODevice::writeData(const char *data, qint64 maxSize).