Sur cette page

QSensor Class

La classe QSensor représente un capteur matériel unique. Plus d'informations...

En-tête : #include <QSensor>
CMake : find_package(Qt6 REQUIRED COMPONENTS Sensors)
target_link_libraries(mytarget PRIVATE Qt6::Sensors)
qmake : QT += sensors
Hérite : QObject
Hérités par :
13 types

QAccelerometer QAmbientLightSensor, , , , , , , , , , , et QAmbientTemperatureSensor QCompass QGyroscope QHumiditySensor QLightSensor QMagnetometer QOrientationSensor QPressureSensor QProximitySensor QRotationSensor QTiltSensor

Types publics

enum AxesOrientationMode { FixedOrientation, AutomaticOrientation, UserOrientation }
enum Feature { Buffering, AlwaysOn, SkipDuplicates, GeoValues, FieldOfView, …, AxesOrientation }

Propriétés

Fonctions publiques

QSensor(const QByteArray &type, QObject *parent = nullptr)
virtual ~QSensor()
void addFilter(QSensorFilter *filter)
qrangelist availableDataRates() const
QSensor::AxesOrientationMode axesOrientationMode() const
int bufferSize() const
bool connectToBackend()
int currentOrientation() const
int dataRate() const
QString description() const
int efficientBufferSize() const
int error() const
QList<QSensorFilter *> filters() const
QByteArray identifier() const
bool isActive() const
bool isAlwaysOn() const
bool isBusy() const
bool isConnectedToBackend() const
bool isFeatureSupported(QSensor::Feature feature) const
int maxBufferSize() const
int outputRange() const
qoutputrangelist outputRanges() const
QSensorReading *reading() const
void removeFilter(QSensorFilter *filter)
void setActive(bool active)
void setAlwaysOn(bool alwaysOn)
void setAxesOrientationMode(QSensor::AxesOrientationMode axesOrientationMode)
void setBufferSize(int bufferSize)
void setCurrentOrientation(int currentOrientation)
void setDataRate(int rate)
void setEfficientBufferSize(int efficientBufferSize)
void setIdentifier(const QByteArray &identifier)
void setMaxBufferSize(int maxBufferSize)
void setOutputRange(int index)
void setSkipDuplicates(bool skipDuplicates)
void setUserOrientation(int userOrientation)
bool skipDuplicates() const
QByteArray type() const
int userOrientation() const

Emplacements publics

bool start()
void stop()

Signaux

void activeChanged()
void alwaysOnChanged()
void availableSensorsChanged()
void axesOrientationModeChanged(QSensor::AxesOrientationMode axesOrientationMode)
void bufferSizeChanged(int bufferSize)
void busyChanged()
void currentOrientationChanged(int currentOrientation)
void dataRateChanged()
void efficientBufferSizeChanged(int efficientBufferSize)
void identifierChanged()
void maxBufferSizeChanged(int maxBufferSize)
void readingChanged()
void sensorError(int error)
void skipDuplicatesChanged(bool skipDuplicates)
void userOrientationChanged(int userOrientation)

Membres publics statiques

QByteArray defaultSensorForType(const QByteArray &type)
QList<QByteArray> sensorTypes()
QList<QByteArray> sensorsForType(const QByteArray &type)

Description détaillée

Le cycle de vie d'un capteur est typiquement :

  • Création d'une sous-classe de QSensor sur la pile ou le tas.
  • Configurer le capteur selon les besoins de l'application.
  • Commencer à recevoir des valeurs.
  • Les données du capteur sont utilisées par l'application.
  • Arrêt de la réception des valeurs.

Les données du capteur sont transmises via QSensorReading et ses sous-classes.

Orientation

Certains capteurs réagissent aux changements d'orientation de l'écran, comme QAccelerometer, QMagnetometer et QRotationSensor. Il s'agit de capteurs orientables. Pour les capteurs orientables, QSensor prend en charge la modification du rapport des valeurs de lecture en fonction de l'orientation de l'écran.

Pour les capteurs orientables, la propriété axesOrientationMode contrôle la manière dont l'orientation affecte les valeurs de lecture.

Dans le mode par défaut, QSensor::FixedOrientation, les valeurs de lecture ne sont pas affectées par l'orientation. Dans le mode QSensor::AutomaticOrientation, les valeurs lues sont automatiquement pivotées en tenant compte de l'orientation actuelle de l'écran. Enfin, dans le mode QSensor::UserOrientation, les valeurs de lecture sont pivotées en fonction de l'orientation spécifiée par l'utilisateur.

Cette fonctionnalité n'est disponible que si elle est prise en charge par le backend et si le capteur est orientable, ce qui peut être vérifié en appelant QSensor::isFeatureSupported() avec le drapeau QSensor::AxesOrientation.

Les valeurs d'orientation sont toujours celles de l'orientation de l'écran, et non de l'orientation de l'appareil. L'orientation de l'écran est l'orientation de l'interface graphique. Par exemple, lorsqu'on fait pivoter un appareil de 90 degrés dans le sens inverse des aiguilles d'une montre, l'orientation de l'écran est compensée par une rotation de 90 degrés dans le sens des aiguilles d'une montre, de sorte que l'interface graphique est toujours orientée vers le haut après que l'appareil a été pivoté. Notez que les applications peuvent verrouiller l'orientation de l'écran, par exemple pour forcer le mode portrait ou paysage. Pour les orientations verrouillées, les capteurs orientables ne réagiront pas aux changements de lecture si l'orientation de l'appareil est modifiée, car les capteurs orientables réagissent uniquement aux changements d'orientation de l'écran. C'est logique, car l'objectif des capteurs orientables est de maintenir l'orientation du capteur en synchronisation avec l'orientation de l'écran.

Les valeurs d'orientation vont de 0 à 270 degrés. L'orientation est appliquée dans le sens des aiguilles d'une montre, par exemple une valeur d'orientation de 90 degrés signifie que l'écran a été tourné de 90 degrés vers la droite par rapport à sa position d'origine, afin de compenser une rotation de l'appareil de 90 degrés vers la gauche.

Voir également QSensorReading.

Documentation sur les types de membres

enum QSensor::AxesOrientationMode

Décrit comment les valeurs de lecture sont affectées par l'orientation de l'écran.

ConstanteValeurDescription
QSensor::FixedOrientation0Aucune rotation automatique n'est appliquée aux valeurs de lecture.
QSensor::AutomaticOrientation1Les valeurs de lecture sont automatiquement tournées en fonction de l'orientation de l'écran.
QSensor::UserOrientation2Les valeurs de lecture sont pivotées en fonction de l'angle de la propriété userOrientation.

Voir également QSensor::axesOrientationMode.

enum QSensor::Feature

Liste des fonctionnalités optionnelles qu'un backend peut prendre en charge.

Les caractéristiques communes à tous les types de capteurs sont les suivantes

ConstanteValeurValeur constante
QSensor::Buffering0Le backend prend en charge la mise en mémoire tampon des relevés, contrôlée par la propriété QSensor::bufferSize.
QSensor::AlwaysOn1Le backend prend en charge la modification de la politique de suspension en cas d'inactivité, contrôlée par la propriété QSensor::alwaysOn.
QSensor::SkipDuplicates5Le backend prend en charge le saut de lectures successives identiques ou très similaires. Cette fonction peut être activée en attribuant la valeur true à la propriété QSensor::skipDuplicates.

Les caractéristiques de QMagnetometer sont les suivantes

ConstanteValeurDescription
QSensor::GeoValues2Le backend prend en charge le renvoi de valeurs géographiques, ce qui peut être contrôlé par la propriété QMagnetometer::returnGeoValues.

Les caractéristiques de QLightSensor sont les suivantes

ConstanteValeurValeur constante
QSensor::FieldOfView3Le backend spécifie son champ de vision, qui peut être lu à partir de la propriété QLightSensor::fieldOfView.

Les caractéristiques de QAccelerometer sont les suivantes

ConstanteValeurValeur constante
QSensor::AccelerationMode4Le backend prend en charge la commutation du mode d'accélération de l'accélérateur à l'aide de la propriété QAccelerometer::accelerationMode.

Les caractéristiques de QPressureSensor sont les suivantes

ConstanteValeurDescription de la propriété
QSensor::PressureSensorTemperature7Le backend fournit la température de la matrice du capteur de pression.

Les caractéristiques de tous les capteurs orientables sont les suivantes

ConstanteValeurDescription
QSensor::AxesOrientation6Le backend prend en charge la modification de l'orientation des axes de la valeur par défaut de QSensor::FixedOrientation à une autre valeur.

Voir également QSensor::isFeatureSupported().

Propriété Documentation

active : bool

Cette propriété contient une valeur indiquant si le capteur est actif.

Cette valeur est vraie si le capteur est actif (il renvoie des valeurs). Dans le cas contraire, cette valeur est fausse.

Notez que la définition de cette valeur à true n'aura pas d'effet immédiat. Au lieu de cela, le capteur sera démarré une fois que la boucle d'événement aura été atteinte.

Fonctions d'accès :

bool isActive() const
void setActive(bool active)

Signal de notification :

void activeChanged()

alwaysOn : bool

Cette propriété contient une valeur indiquant si le capteur doit continuer à fonctionner lorsque l'écran est éteint.

Certaines plateformes ont pour politique de suspendre les capteurs lorsque l'écran s'éteint. En définissant cette propriété à true, vous vous assurez que le capteur continue à fonctionner.

Fonctions d'accès :

bool isAlwaysOn() const
void setAlwaysOn(bool alwaysOn)

Notificateur signal :

[read-only] availableDataRates : qrangelist

Cette propriété contient les débits de données pris en charge par le capteur.

Il s'agit d'une liste des débits de données pris en charge par le capteur. Ils sont mesurés en Hertz.

Les entrées de la liste peuvent représenter des débits discrets ou une gamme continue de débits. Un débit discret est indiqué par le fait que les deux valeurs sont identiques.

Notez que cette information n'est pas obligatoire, car tous les capteurs n'ont pas un taux auquel ils fonctionnent. Dans ce cas, la liste sera vide.

Fonctions d'accès :

qrangelist availableDataRates() const

Voir également QSensor::dataRate et qrangelist.

axesOrientationMode : AxesOrientationMode

Cette propriété contient le mode qui affecte la façon dont l'orientation de l'écran modifie les valeurs de lecture.

Lorsque la propriété vaut FixedOrientation, qui est le mode par défaut, aucune rotation automatique n'est appliquée à la lecture. C'est le seul mode disponible pour les backends qui ne prennent pas en charge la fonctionnalité QSensor::AxesOrientation.

Lorsque l'option AutomaticOrientation est sélectionnée, les valeurs de lecture sont automatiquement pivotées lorsque l'orientation de l'écran change. En fait, l'orientation de l'écran est annulée.

À titre d'exemple, supposons que l'appareil soit tourné de 180 degrés et que l'orientation de l'écran soit également tournée de 180 degrés par rapport à l'orientation d'origine. Sans l'orientation automatique des axes, les valeurs de lecture seraient modifiées : les valeurs X et Y seraient annulées, ce qui obligerait le développeur de l'application à annuler manuellement la négation dans le code de l'application. L'orientation automatique des axes effectue cette opération automatiquement. Dans ce mode, les valeurs X et Y sont identiques à celles de l'orientation par défaut de l'écran.

Cette rotation automatique des axes est pratique dans certains cas d'utilisation, par exemple dans une application de niveau à bulle qui mesure le niveau d'une surface en regardant la valeur de l'axe X d'un accéléromètre. Lorsque l'appareil et l'orientation de l'écran changent de 90 degrés, le développeur de l'application n'a pas besoin de changer quoi que ce soit, il peut continuer à utiliser la valeur de l'axe X même si l'appareil est tourné. Sans l'orientation automatique des axes, le développeur d'applications devrait regarder les valeurs Y à la place, ajoutant ainsi du code à l'application qui lit un axe différent en fonction de l'orientation de l'écran.

Le mode UserOrientation est assez similaire au mode AutomaticOrientation, à ceci près que l'orientation de l'écran est contrôlée manuellement au lieu d'être déterminée automatiquement. L'angle de la propriété userOrientation est alors utilisé pour faire pivoter les valeurs de lecture.

Comme la rotation des valeurs de lecture est basée sur l'orientation de l'écran, les valeurs Z ne changeront jamais, car l'axe Z est perpendiculaire à l'écran. Comme l'orientation de l'écran change par pas de 90 degrés, la rotation des valeurs de lecture se fait également par pas de 90 degrés.

Cette propriété n'est utilisée que pour les capteurs orientables.

Fonctions d'accès :

QSensor::AxesOrientationMode axesOrientationMode() const
void setAxesOrientationMode(QSensor::AxesOrientationMode axesOrientationMode)

Signal de notification :

void axesOrientationModeChanged(QSensor::AxesOrientationMode axesOrientationMode)

bufferSize : int

Cette propriété indique la taille de la mémoire tampon. Par défaut, la taille de la mémoire tampon est de 1, ce qui signifie qu'il n'y a pas de mise en mémoire tampon. Si la taille maximale de la mémoire tampon est de 1, cela signifie que la mémoire tampon n'est pas prise en charge par le capteur.

Si la valeur de bufferSize est supérieure à maxBufferSize, maxBufferSize sera utilisé.

La mise en mémoire tampon est activée lorsque bufferSize est supérieur à 1. Le capteur collectera le nombre d'échantillons demandé et les transmettra tous à l'application en une seule fois. Il est donc particulièrement important que l'application traite chaque lecture immédiatement ou enregistre les valeurs à un autre endroit.

Si stop() est appelé lorsque la mise en mémoire tampon est en cours, la mémoire tampon partielle n'est pas délivrée.

Lorsque le capteur est démarré avec l'option de mise en mémoire tampon, les valeurs sont collectées à partir de ce moment. Il n'y a pas de tampon préexistant qui puisse être utilisé.

Certains backends ne prennent en charge que l'activation ou la désactivation de la mémoire tampon et ne permettent pas d'en contrôler la taille. Dans ce cas, les propriétés maxBufferSize et efficientBufferSize peuvent ne pas être définies du tout, même si la mise en mémoire tampon est prise en charge. La définition de la propriété bufferSize à une valeur supérieure à 1 activera la mise en mémoire tampon. Après le démarrage du capteur, la propriété bufferSize sera fixée à la valeur réelle par le backend.

Fonctions d'accès :

int bufferSize() const
void setBufferSize(int bufferSize)

Signal de notification :

void bufferSizeChanged(int bufferSize)

Voir aussi QSensor::maxBufferSize et QSensor::efficientBufferSize.

[read-only] busy : bool

Cette propriété contient une valeur indiquant si le capteur est occupé.

Certains capteurs peuvent être présents sur le système mais ne pas pouvoir être utilisés. Cette fonction renvoie la valeur true si le capteur est occupé. Vous ne pourrez pas utiliser le capteur à l'adresse start().

Notez que cette fonction ne renvoie pas la valeur true si vous utilisez le capteur, mais seulement si un autre processus utilise le capteur.

Fonctions d'accès :

bool isBusy() const

Signal de notification :

void busyChanged()

Voir également busyChanged().

[read-only] connectedToBackend : bool

Cette propriété contient une valeur indiquant si le capteur s'est connecté à un backend.

Un capteur qui n'a pas été connecté à un backend ne peut rien faire d'utile.

Appelez la méthode connectToBackend() pour forcer le capteur à se connecter immédiatement à un backend. Cette méthode est automatiquement appelée si vous appelez start(). Vous ne devez donc le faire que si vous avez besoin d'accéder aux propriétés du capteur (par exemple, pour interroger les métadonnées du capteur avant de l'utiliser).

Fonctions d'accès :

bool isConnectedToBackend() const

[read-only] currentOrientation : int

Cette propriété indique l'orientation actuelle utilisée pour la rotation des valeurs de lecture.

Cette orientation peut être différente de l'orientation de l'écran. Par exemple, dans le mode FixedOrientation, les valeurs lues ne sont pas tournées, et cette propriété vaut donc 0.

Dans le mode UserOrientation, les lectures sont pivotées en fonction de la propriété userOrientation, et cette propriété est donc égale à la propriété userOrientation.

Dans le mode AutomaticOrientation, les lectures sont pivotées en fonction de l'orientation de l'écran, et cette propriété sera donc égale à l'orientation actuelle de l'écran.

Cette propriété est définie par le backend et n'est valable que pour les capteurs orientables.

Fonctions d'accès :

int currentOrientation() const

Signal de notification :

void currentOrientationChanged(int currentOrientation)

dataRate : int

Cette propriété indique le débit de données auquel le capteur doit fonctionner.

Elle est mesurée en Hertz.

Le débit de données est la fréquence maximale à laquelle le capteur peut détecter des changements.

La définition de cette propriété n'est pas portable et peut entraîner des conflits avec d'autres applications. Consultez le backend du capteur et la documentation de la plateforme pour connaître la politique concernant les applications multiples qui demandent un débit de données.

La valeur par défaut (0) signifie que l'application ne se préoccupe pas du débit de données. Les applications doivent envisager d'utiliser une interrogation de la valeur actuelle basée sur un minuteur ou s'assurer que le code qui traite les valeurs peut s'exécuter très rapidement car la plateforme peut fournir des mises à jour des centaines de fois par seconde.

Cette valeur doit être définie avant d'appeler start() car le capteur peut ne pas remarquer les changements de cette valeur pendant qu'il est en cours d'exécution.

Notez qu'il n'existe aucun mécanisme permettant de déterminer le débit de données actuellement utilisé par la plate-forme.

Fonctions d'accès :

int dataRate() const
void setDataRate(int rate)

Signal Notificateur :

void dataRateChanged()

Voir aussi QSensor::availableDataRates.

[read-only] description : QString

Cette propriété contient une chaîne descriptive pour le capteur.

Fonctions d'accès :

QString description() const

[read-only] efficientBufferSize : int

Cette propriété contient la taille de tampon la plus efficace. Normalement, elle vaut 1 (ce qui signifie qu'aucune taille particulière n'est la plus efficace). Certains pilotes de capteurs disposent d'une mémoire tampon FIFO, ce qui rend plus efficace la transmission en une seule fois d'une quantité de données équivalente à la taille de la mémoire FIFO.

Fonctions d'accès :

int efficientBufferSize() const

Signal de notification :

void efficientBufferSizeChanged(int efficientBufferSize)

Voir également QSensor::bufferSize et QSensor::maxBufferSize.

[read-only] error : int

Cette propriété contient le dernier code d'erreur défini sur le capteur.

Il est à noter que les codes d'erreur sont spécifiques à chaque capteur.

Fonctions d'accès :

int error() const

Signal de notification :

void sensorError(int error)

identifier : QByteArray

Cette propriété contient l'identifiant du backend pour le capteur.

Notez que l'identifiant est rempli automatiquement lorsque le capteur est connecté à un backend. Si vous souhaitez connecter un backend spécifique, vous devez appeler setIdentifier() avant connectToBackend().

Fonctions d'accès :

QByteArray identifier() const
void setIdentifier(const QByteArray &identifier)

Notifier signal :

void identifierChanged()

[read-only] maxBufferSize : int

Cette propriété contient la taille maximale de la mémoire tampon.

Notez qu'elle peut être égale à 1, auquel cas le capteur ne prend en charge aucune forme de mise en mémoire tampon. Dans ce cas, isFeatureSupported(QSensor::Buffering) renverra également false.

Fonctions d'accès :

int maxBufferSize() const

Signal du notificateur :

void maxBufferSizeChanged(int maxBufferSize)

Voir également QSensor::bufferSize et QSensor::efficientBufferSize.

outputRange : int

Cette propriété contient la plage de sortie utilisée par le capteur.

Cette valeur représente l'index de la liste QSensor::outputRanges à utiliser.

La définition de cette propriété n'est pas portable et peut entraîner des conflits avec d'autres applications. Consultez le backend du capteur et la documentation de la plateforme pour connaître la politique concernant les applications multiples qui demandent une plage de sortie.

La valeur par défaut (-1) signifie que l'application ne se préoccupe pas de la plage de sortie.

Notez qu'il n'existe aucun mécanisme permettant de déterminer la plage de sortie actuellement utilisée par la plateforme.

Fonctions d'accès :

int outputRange() const
void setOutputRange(int index)

Voir aussi QSensor::outputRanges.

[read-only] outputRanges : qoutputrangelist

Cette propriété contient une liste des plages de sortie prises en charge par le capteur.

Un capteur peut avoir plus d'une plage de sortie. Généralement, cela permet d'obtenir une plus grande plage de mesure au prix d'une baisse de la précision.

Notez que cette information n'est pas obligatoire. Elle n'est généralement disponible que pour les capteurs dont les plages de sortie sont sélectionnables (comme les accéléromètres classiques).

Fonctions d'accès :

qoutputrangelist outputRanges() const

Voir également QSensor::outputRange et qoutputrangelist.

[read-only] reading : QSensorReading*

Cette propriété contient la classe de lecture.

La classe de lecture permet d'accéder aux relevés des capteurs. L'objet lecture est un cache volatile de la lecture la plus récente du capteur qui a été reçue, de sorte que l'application doit traiter les lectures immédiatement ou enregistrer les valeurs quelque part pour un traitement ultérieur.

Notez que cet objet renvoie 0 tant qu'un backend de capteur n'est pas connecté à un backend.

Notez également que les relevés ne sont pas immédiatement disponibles après l'appel de start(). Les applications doivent attendre que le signal readingChanged() soit émis.

Fonctions d'accès :

QSensorReading *reading() const

Signal Notifier :

Voir également isConnectedToBackend() et start().

skipDuplicates : bool

Indique si les valeurs de lecture en double doivent être omises.

Lorsque le saut des doublons est activé, les relevés successifs présentant des valeurs identiques ou très similaires sont omis. Cela permet de réduire la quantité de traitement effectué, car moins de relevés de capteurs sont disponibles. Par conséquent, les relevés arrivent à un intervalle irrégulier.

Le saut de doublons n'est pas seulement activé pour les relevés qui sont exactement les mêmes, mais aussi pour les relevés qui sont assez similaires, car chaque capteur a un peu d'instabilité, même si l'appareil n'est pas déplacé.

La prise en charge de cette propriété dépend du backend. Utilisez isFeatureSupported() pour vérifier si elle est prise en charge par la plateforme actuelle.

Le saut de doublon est désactivé par défaut.

Le saut de duplicata prend effet lorsque le capteur est démarré, la modification de la propriété pendant que le capteur est actif n'a pas d'effet immédiat.

Fonctions d'accès :

bool skipDuplicates() const
void setSkipDuplicates(bool skipDuplicates)

Signal de notification :

void skipDuplicatesChanged(bool skipDuplicates)

[read-only] type : const QByteArray

Cette propriété contient le type de capteur.

Fonctions d'accès :

QByteArray type() const

userOrientation : int

Cette propriété contient l'angle utilisé pour la rotation des valeurs de lecture dans le mode UserOrientation.

Lorsque la propriété axesOrientationMode est définie sur UserOrientation, l'angle de rotation des valeurs de lecture est tiré de cette propriété. Dans les autres modes, cette propriété n'a aucun effet.

La valeur par défaut est 0. Les seules valeurs valables sont 0, 90, 180 et 270, car ce sont les seules orientations possibles de l'écran.

Cette propriété n'est valable que pour les capteurs orientables.

Fonctions d'accès :

int userOrientation() const
void setUserOrientation(int userOrientation)

Signal Notificateur :

void userOrientationChanged(int userOrientation)

Member Function Documentation

[explicit] QSensor::QSensor(const QByteArray &type, QObject *parent = nullptr)

Construit le capteur type comme un enfant de parent.

N'utilisez pas ce constructeur s'il existe une classe dérivée pour le type de capteur en question.

La mauvaise méthode consiste à utiliser le constructeur de la classe de base :

QSensor *magnetometer = new QSensor(QMagnetometer::sensorType, this);

La bonne méthode consiste à créer une instance de la classe dérivée :

QMagnetometer *magnetometer = new QMagnetometer(this);

Les classes dérivées ont des propriétés et des membres de données supplémentaires qui sont nécessaires pour certaines fonctionnalités telles que la prise en charge des valeurs géographiques dans QMagnetometer ou la prise en charge du mode d'accélération dans QAccelerometer. Ces fonctionnalités ne fonctionneront correctement que si l'on crée une instance de capteur à partir d'une sous-classe de QSensor.

N'utilisez ce constructeur que si aucune classe de capteur dérivée n'est disponible. Notez que tous les capteurs intégrés ont une classe dérivée, de sorte que l'utilisation de ce constructeur ne devrait être nécessaire que lors de l'implémentation de capteurs personnalisés.

[virtual noexcept] QSensor::~QSensor()

Détruit le capteur. Arrête le capteur s'il n'a pas déjà été arrêté.

[signal] void QSensor::activeChanged()

Ce signal est émis lorsque la propriété QSensor::active a été modifiée.

Note : Signal de notification pour la propriété active.

Voir aussi QSensor::active.

void QSensor::addFilter(QSensorFilter *filter)

Ajouter un filter au capteur.

Le capteur n'est pas propriétaire du filtre. QSensorFilter informera le capteur s'il est détruit.

Voir aussi QSensorFilter.

[signal] void QSensor::alwaysOnChanged()

Ce signal est émis lorsque la propriété alwaysOn est modifiée.

Note : Signal de notification pour la propriété alwaysOn.

[signal] void QSensor::availableSensorsChanged()

Ce signal est émis lorsque la liste des capteurs disponibles a changé. Les capteurs disponibles pour un programme ne changent généralement pas au fil du temps, mais certains d'entre eux peuvent représenter du matériel qui n'est pas connecté en permanence. Par exemple, une manette de jeu connectée via Bluetooth devient disponible lorsqu'elle est allumée et devient indisponible lorsqu'elle est éteinte.

Voir également QSensor::sensorTypes() et QSensor::sensorsForType().

[signal] void QSensor::busyChanged()

Ce signal est émis lorsque le capteur n'est plus occupé. Il peut être utilisé pour saisir un capteur lorsqu'il devient disponible.

sensor.start();
if (sensor.isBusy()) {
    // need to wait for busyChanged signal and try again
}

Remarque : signal de notification pour la propriété busy.

[invokable] bool QSensor::connectToBackend()

Essaie de se connecter à un backend de capteur.

Retourne true si un backend approprié a pu être trouvé, false sinon.

Le type doit être défini avant d'appeler cette méthode si vous utilisez directement QSensor.

Remarque : cette fonction peut être invoquée via le système de méta-objets et à partir de QML. Voir Q_INVOKABLE.

Voir également isConnectedToBackend().

[static] QByteArray QSensor::defaultSensorForType(const QByteArray &type)

Renvoie l'identifiant par défaut du capteur pour type. Il est défini dans un fichier de configuration et peut être modifié si nécessaire. Si aucune valeur par défaut n'est disponible, le système renvoie le premier capteur enregistré pour type.

Notez qu'il existe une logique spéciale pour éviter que les backends du plugin générique ne deviennent la valeur par défaut lorsqu'un autre backend est enregistré pour le même type. Cette logique signifie qu'un identifiant de backend commençant par generic. ne sera utilisé par défaut que si aucun autre backend n'a été enregistré pour ce type ou s'il est spécifié dans Sensors.conf.

Voir aussi Détermination du capteur par défaut pour un type.

QList<QSensorFilter *> QSensor::filters() const

Renvoie les filtres actuellement attachés au capteur.

Voir aussi QSensorFilter.

[invokable] bool QSensor::isFeatureSupported(QSensor::Feature feature) const

Vérifie si une fonctionnalité spécifique est prise en charge par le backend.

QtSensors Le système d'information sur les capteurs prend en charge une API riche pour le contrôle et la fourniture d'informations sur les capteurs. Naturellement, toutes ces fonctionnalités ne peuvent pas être prises en charge par tous les backends.

Pour vérifier si le backend actuel prend en charge la fonctionnalité feature, appelez cette fonction.

Le backend doit être connecté, sinon la fonction renvoie un message faux. L'appel à connectToBackend() ou start() créera une connexion avec le backend.

Les backends doivent implémenter QSensorBackend::isFeatureSupported() pour que cela fonctionne.

Retourne si la fonctionnalité est prise en charge ou non si le backend est connecté, ou false si le backend n'est pas connecté.

Remarque : cette fonction peut être invoquée via le système de méta-objets et à partir de QML. Voir Q_INVOKABLE.

[signal] void QSensor::readingChanged()

Ce signal est émis lorsqu'un nouveau relevé de capteur est reçu.

La lecture du capteur peut être trouvée dans la propriété QSensor::reading. Notez que l'objet de lecture est un cache volatile de la lecture la plus récente du capteur qui a été reçue, de sorte que l'application doit traiter la lecture immédiatement ou sauvegarder les valeurs quelque part pour un traitement ultérieur.

Avant que ce signal ne soit émis pour la première fois, l'objet lecture aura des données non initialisées.

Note : Signal de notification pour la propriété reading.

Voir aussi start().

void QSensor::removeFilter(QSensorFilter *filter)

Retirez filter du capteur.

Voir également QSensorFilter.

[signal] void QSensor::sensorError(int error)

Ce signal est émis lorsqu'un code error est défini sur le capteur. Notez que certaines erreurs peuvent entraîner l'arrêt du fonctionnement du capteur. Vous devez appeler isActive() pour déterminer si le capteur fonctionne toujours.

Note : Signal de notification pour la propriété error.

[static] QList<QByteArray> QSensor::sensorTypes()

Renvoie une liste de tous les types de capteurs.

[static] QList<QByteArray> QSensor::sensorsForType(const QByteArray &type)

Renvoie une liste d'identifiants pour chacun des capteurs de type. Si aucun capteur de ce type n'est disponible, la liste sera vide.

void QSensor::setCurrentOrientation(int currentOrientation)

Définit l'orientation actuelle de l'écran à currentOrientation. Cette fonction doit être appelée depuis le backend lorsque l'orientation de l'écran ou la propriété userOrientation change.

Voir aussi currentOrientation().

void QSensor::setEfficientBufferSize(int efficientBufferSize)

Fixe la taille de la mémoire tampon efficace à efficientBufferSize. Cette fonction doit être appelée depuis le backend.

Voir aussi efficientBufferSize().

void QSensor::setMaxBufferSize(int maxBufferSize)

Fixe la taille maximale de la mémoire tampon à maxBufferSize. Cette fonction doit être appelée depuis le backend.

Voir aussi maxBufferSize().

void QSensor::setSkipDuplicates(bool skipDuplicates)

Définit le saut de doublon à skipDuplicates.

Note : Fonction de définition de la propriété skipDuplicates.

Voir aussi skipDuplicates().

[signal] void QSensor::skipDuplicatesChanged(bool skipDuplicates)

Ce signal est émis lorsque la propriété skipDuplicates est modifiée.

Note : Signal de notification pour la propriété skipDuplicates.

[slot] bool QSensor::start()

Commence à récupérer les valeurs du capteur. Retourne true si le capteur a démarré, false dans le cas contraire.

Le capteur peut ne pas démarrer pour plusieurs raisons.

Une fois qu'une application a démarré un capteur, elle doit attendre que le capteur reçoive une nouvelle valeur avant de pouvoir interroger les valeurs du capteur. Cela est dû à la manière dont le capteur reçoit les valeurs du système. Les capteurs n'interrogent pas (en général) pour obtenir de nouvelles valeurs ; les nouvelles valeurs sont transmises aux capteurs au fur et à mesure.

Par exemple, ce code ne fonctionnera pas comme prévu.

sensor->start();
sensor->reading()->x(); // no data available

Pour fonctionner correctement, le code qui accède à la lecture doit s'assurer que le signal readingChanged() a été émis.

    connect(sensor, SIGNAL(readingChanged()), this, SLOT(checkReading()));
    sensor->start();
}
void MyClass::checkReading() {
    sensor->reading()->x();

Voir également QSensor::busy.

[slot] void QSensor::stop()

Arrêter de récupérer les valeurs du capteur.

Cela libère le capteur pour que d'autres processus puissent l'utiliser.

Voir également QSensor::busy.

Non-membres associés

[alias] qoutputrangelist

Ce type est défini comme une liste de valeurs qoutputrange.

typedef QList<qoutputrange> qoutputrangelist;

Voir aussi QList, qoutputrange, et QSensor::outputRanges.

[alias] qrange

Ce type est défini comme un QPair.

typedef QPair<int,int> qrange;

Voir aussi QPair, qrangelist, et QSensor::availableDataRates.

[alias] qrangelist

Ce type est défini comme une liste de valeurs qrange.

typedef QList<qrange> qrangelist;

Voir aussi QList, qrange, et QSensor::availableDataRates.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.