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;
}

Documentation des fonctions membres

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

Crée un nouvel objet de port série à l'aide de l'parent on fournie.

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

Crée un nouvel objet de port série avec l’ parent on fournie afin de représenter le port série à l’aide de la classe d’aide spécifiée serialPortInfo.

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

Crée un nouvel objet de port série à partir de l'parent fournie afin de représenter le port série dont l'name est spécifiée.

Le nom doit respecter 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 une fois que la vitesse de transmission a été modifiée. La nouvelle vitesse de transmission est transmise via baudRate et les directions via directions.

Voir également 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 également 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 la fonction flush() est appelée.

Voir également 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 à partir du port série ; sinon, renvoie ` false`.

Voir également readLine().

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

Efface tous les caractères du tampon de sortie ou d’entrée, selon les instructions fournies directions. Cela inclut l’effacement des tampons internes de la classe et des tampons UART (pilote). Met également fin aux opérations de lecture ou d’écriture en cours. En cas de succès, renvoie true; sinon, renvoie false.

[override virtual] void QSerialPort::close()

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

Voir également QIODevice::close().

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

Ce signal est émis après la modification des bits de données d'une trame. Les nouveaux bits de données d'une trame sont transmis sous la forme « 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 changé. Le nouvel état (haut ou bas) du signal de ligne DTR est transmis via la propriété set.

Voir également QSerialPort::dataTerminalReady.

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

Ce signal est émis lorsqu'une erreur se produit au niveau du port série. L'error spécifiée décrit le type d'erreur survenue.

Voir également QSerialPort::error.

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

Ce signal est émis après la modification du mode de contrôle du débit. Le nouveau mode de contrôle du débit est transmis sous la forme 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 blocage. 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 vers le 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 rendu à la boucle d'événements. En l'absence de boucle d'événements, appelez plutôt ` waitForBytesWritten()`.

Voir également write() et waitForBytesWritten().

QSerialPort::Handle QSerialPort::handle() const

Si la plateforme est prise en charge et que le port série est ouvert, renvoie le descripteur natif 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 périphérique séquentiel.

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

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

Ouvre le port série en utilisant le mode OpenMode mode, puis renvoie true en cas de succès ; sinon, 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 configuration des paramètres souhaités échoue, la méthode renvoie false et ferme automatiquement le port.

Voir également QIODeviceBase::OpenMode et setPort().

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

Ce signal est émis une fois que le mode de contrôle de parité a été modifié. Le nouveau mode de contrôle de parité est transmis via la propriété parity.

Voir également ` QSerialPort::parity`.

QSerialPort::PinoutSignals QSerialPort::pinoutSignals()

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

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

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

QString QSerialPort::portName() const

Renvoie le nom défini par la fonction ` setPort()` ou transmis au constructeur ` QSerialPort `. Ce nom est abrégé, c'est-à-dire qu'il est extrait et converti à partir de l'emplacement de la variable système interne de l'appareil. L'algorithme de conversion dépend de la plateforme :

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 (valeur 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émentation de : QIODevice::readData(char *data, qint64 maxSize).

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

Réimplémentation de : 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 changé. Le nouvel état (haut ou bas) du signal de ligne RTS est transmis via la propriété set.

Voir également QSerialPort::requestToSend.

void QSerialPort::setPort(const QSerialPortInfo &serialPortInfo)

Définit le port enregistré dans l'instance d'informations sur le port série serialPortInfo.

Voir également portName() et QSerialPortInfo.

void QSerialPort::setPortName(const QString &name)

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

Le nom du port série peut être fourni sous forme de nom court ou, si nécessaire, d’emplacement système complet.

Voir également portName() et QSerialPortInfo.

void QSerialPort::setReadBufferSize(qint64 size)

Définit la taille du tampon de lecture interne de ` QSerialPort` à size octets.

Si la taille du tampon est limitée à une certaine valeur, QSerialPort ne mettra pas en 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 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 streaming en temps réel) ou si le port série doit être protégé contre la réception d’un volume trop important de données, ce qui pourrait finir par entraîner un épuisement de la mémoire de l’application.

Le passage d’une valeur négative désactive le tampon interne, bloquant ainsi toute lecture.

Voir également readBufferSize() et read().

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

Définit la taille du tampon d'écriture interne de la fonction ` QSerialPort` à size octets.

L'envoi de données via un port série est relativement lent ; par conséquent, dans la pratique, les données ne sont pas envoyées immédiatement lorsque la fonction write() est appelée. Elles sont d'abord stockées dans un tampon intermédiaire, puis écrites par blocs.

Ainsi, l'écriture d'un volume trop important de données, ou à un débit supérieur à celui que le port série sous-jacent peut gérer, peut entraîner une augmentation de la taille du tampon interne. Cela peut finir par provoquer un épuisement de la mémoire de l'application, en particulier sur un appareil disposant de faibles ressources mémoire.

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

Le fait de passer 0 à cette méthode signifie que le tampon d’écriture n’est pas limité et que toutes les données transmises à write() sont mises en tampon. Il s’agit du comportement par défaut.

Le passage d’une valeur négative a le même effet que le passage de 0.

Cette fonction a été introduite dans Qt 6.10.

Voir également ` 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 également 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 d'une trame est transmis via la propriété stopBits.

Voir également QSerialPort::stopBits.

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

Réimplémentation de : QIODevice::waitForBytesWritten(int msecs).

Cette fonction reste bloquée 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 expire après msecs millisecondes ; le délai d’expiration par défaut est de 30 000 millisecondes. Si msecs vaut -1, cette fonction n’expire 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 a expiré).

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

Réimplémentation de : QIODevice::waitForReadyRead(int msecs).

Cette fonction reste bloquée jusqu’à ce que de nouvelles données soient disponibles en lecture et que le signal readyRead() ait été émis. La fonction expire après msecs millisecondes ; le délai d’expiration par défaut est de 30000 millisecondes. Si msecs vaut -1, cette fonction n’expire 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 a expiré).

Voir également waitForBytesWritten().

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

Renvoie la taille du tampon d'écriture interne.

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

Cette fonction a été introduite dans Qt 6.10.

Voir également setWriteBufferSize() et write().

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

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