QSensor Class
La classe QSensor représente un capteur matériel unique. En savoir plus...
| En-tête : | #include <QSensor> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Sensors) target_link_libraries(mytarget PRIVATE Qt6::Sensors) |
| qmake : | QT += sensors |
| Hérite de : | QObject |
| Hérité par : |
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
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) |
Éléments non membres associés
Description détaillée
Le cycle de vie d'un capteur se déroule généralement comme suit :
- Créer une sous-classe de QSensor sur la pile ou le tas.
- Configurer 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. On les appelle des capteurs orientables. Pour les capteurs orientables, QSensor prend en charge la modification de la transmission des valeurs de mesure 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 mesurées.
En mode par défaut ( QSensor::FixedOrientation), les valeurs de mesure ne sont pas affectées par l’orientation. En mode QSensor::AutomaticOrientation, les valeurs de mesure sont automatiquement pivotées en tenant compte de l’orientation actuelle de l’écran. Enfin, en mode QSensor::UserOrientation, les valeurs de mesure sont pivotées selon une 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 indiquées ici correspondent toujours à l’orientation de l’écran, et non à celle de l’appareil. L’orientation de l’écran correspond à celle de l’interface graphique. Par exemple, lorsque l’on fait pivoter un appareil de 90 degrés dans le sens antihoraire, l’orientation de l’écran compense ce mouvement en pivotant de 90 degrés dans le sens horaire, de sorte que l’interface graphique reste à l’endroit après la rotation de l’appareil. Notez que les applications peuvent verrouiller l’orientation de l’écran, par exemple pour forcer le mode portrait ou paysage. Lorsque l’orientation est verrouillée, les capteurs orientables ne réagissent pas aux changements de lecture si l’orientation de l’appareil est modifiée, car ils ne réagissent qu’aux changements d’orientation de l’écran. Cela est logique, puisque le but des capteurs orientables est de maintenir l’orientation du capteur synchronisée avec celle de l’écran.
Les valeurs d’orientation vont de 0 à 270 degrés. L’orientation s’applique dans le sens des aiguilles d’une montre ; par exemple, une valeur d’orientation de 90 degrés signifie que l’écran a été pivoté 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
Explique comment l'orientation de l'écran influe sur les valeurs affichées.
| Constante | Valeur | Description |
|---|---|---|
QSensor::FixedOrientation | 0 | Aucune rotation automatique n'est appliquée aux valeurs de lecture. |
QSensor::AutomaticOrientation | 1 | Les valeurs de lecture sont automatiquement pivotées en fonction de l'orientation de l'écran. |
QSensor::UserOrientation | 2 | Les valeurs de lecture sont pivotées en fonction de l'angle défini par la propriété « userOrientation ». |
Voir également QSensor::axesOrientationMode.
enum QSensor::Feature
Répertorie les fonctionnalités optionnelles qu’un backend peut prendre en charge.
Les fonctionnalités communes à tous les types de capteurs sont les suivantes :
| Constante | Valeur | Description |
|---|---|---|
QSensor::Buffering | 0 | Le backend prend en charge la mise en mémoire tampon des relevés, contrôlée par la propriété QSensor::bufferSize. |
QSensor::AlwaysOn | 1 | Le backend prend en charge la modification de la politique de mise en veille en cas d'inactivité, contrôlée par la propriété ` QSensor::alwaysOn `. |
QSensor::SkipDuplicates | 5 | Le backend prend en charge l’omission des mesures successives identiques ou très similaires. Cette fonctionnalité peut être activée en définissant la propriété QSensor::skipDuplicates sur « true ». |
Les fonctionnalités de ` QMagnetometer ` sont les suivantes :
| Constante | Valeur | Description |
|---|---|---|
QSensor::GeoValues | 2 | Le backend prend en charge le renvoi de valeurs géographiques, qui peuvent être contrôlées à l'aide de la propriété « QMagnetometer::returnGeoValues ». |
Les fonctionnalités de QLightSensor sont les suivantes :
| Constante | Valeur | Description |
|---|---|---|
QSensor::FieldOfView | 3 | Le 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 :
| Constante | Valeur | Description |
|---|---|---|
QSensor::AccelerationMode | 4 | Le backend prend en charge la modification du mode d'accélération de l'accéléromètre via la propriété « QAccelerometer::accelerationMode ». |
Les fonctionnalités de QPressureSensor sont les suivantes :
| Constante | Valeur | Description |
|---|---|---|
QSensor::PressureSensorTemperature | 7 | Le backend fournit la température de la puce du capteur de pression |
Les caractéristiques de tous les capteurs orientables sont les suivantes :
| Constante | Valeur | Description |
|---|---|---|
QSensor::AxesOrientation | 6 | Le backend prend en charge la modification de l'orientation des axes, qui par défaut est définie sur QSensor::FixedOrientation, pour une autre valeur. |
Voir également QSensor::isFeatureSupported().
Documentation des propriétés
active : bool
Cette propriété contient une valeur indiquant si le capteur est actif.
Elle est définie sur « true » si le capteur est actif (s'il renvoie des valeurs). Elle est définie sur « false » dans le cas contraire.
Notez que le fait de définir cette valeur sur « true » n'aura pas d'effet immédiat. Le capteur sera en effet lancé dès que la boucle d'événements 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 principe de suspendre les capteurs lorsque l'écran s'éteint. En définissant cette propriété sur « true », vous vous assurez que le capteur continue de fonctionner.
Fonctions d'accès :
| bool | isAlwaysOn() const |
| void | setAlwaysOn(bool alwaysOn) |
Signal de notification :
| void | alwaysOnChanged() |
[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. Mesurés en hertz.
Les entrées de la liste peuvent correspondre à des débits discrets ou à une plage continue de débits. Un débit discret est indiqué par deux valeurs identiques.
Notez que cette information n'est pas obligatoire, car tous les capteurs ne fonctionnent pas nécessairement à une fréquence donnée. 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é définit le mode qui détermine la manière dont l'orientation de l'écran influe sur les valeurs relevées.
Lorsqu’elle est définie sur « FixedOrientation », qui est le mode par défaut, aucune rotation automatique n’est appliquée aux valeurs affichées. Il s’agit du seul mode disponible pour les backends qui ne prennent pas en charge la fonctionnalité « QSensor::AxesOrientation ».
Lorsqu’elle est définie sur « AutomaticOrientation », les valeurs de lecture sont automatiquement pivotées lorsque l’orientation de l’écran change. En effet, l’orientation de l’écran est annulée.
À titre d’exemple, supposons que l’appareil soit pivoté de 180 degrés et que, par conséquent, l’orientation de l’écran soit également pivotée de 180 degrés par rapport à l’orientation native. Sans l’orientation automatique des axes, les valeurs mesurées seraient alors modifiées : les valeurs X et Y seraient toutes deux inversées, ce qui obligerait le développeur d’applications à annuler manuellement cette inversion dans le code de l’application. L’orientation automatique des axes s’en charge automatiquement ; dans ce mode, les valeurs X et Y seraient identiques à celles de l’orientation d’écran par défaut.
Cette rotation automatique des axes s’avère pratique dans certains cas d’utilisation, par exemple dans une application de niveau à bulle qui mesure le niveau d’une surface en analysant la valeur de l’axe X d’un accéléromètre. Lorsque l’orientation de l’appareil et de l’écran change de 90 degrés, le développeur d’applications n’a rien à modifier ; il peut continuer à utiliser la valeur de l’axe X même si l’appareil est pivoté. Sans orientation automatique des axes, le développeur d’applications devrait alors se baser sur les valeurs Y, ce qui l’obligerait à ajouter du code à l’application pour lire les données à partir d’un axe différent en fonction de l’orientation de l’écran.
Le mode « UserOrientation » est assez similaire à « AutomaticOrientation », à la différence 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.
La rotation des valeurs de lecture étant basée sur l’orientation de l’écran, les valeurs Z ne changent jamais, car l’axe Z est perpendiculaire à l’écran. L’orientation de l’écran changeant par paliers de 90 degrés, la rotation des valeurs de lecture s’effectue également par paliers 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 mise en mémoire tampon n'est pas prise en charge par le capteur.
Si vous définissez bufferSize sur une valeur supérieure à maxBufferSize, la mise en mémoire tampon ( maxBufferSize ) sera activée.
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. Ils seront transmis à l’application sous la forme d’une rafale de valeurs modifiées ; il est donc particulièrement important que l’application traite chaque valeur immédiatement ou enregistre les valeurs ailleurs.
Si la fonction ` stop()` est appelée alors que la mise en mémoire tampon est en cours, le tampon partiel n’est pas transmis.
Lorsque le capteur est lancé avec l’option de mise en mémoire tampon, les valeurs sont collectées à partir de ce moment-là. Il n’existe pas de mémoire tampon préexistante pouvant être utilisée.
Certains backends prennent uniquement en charge l’activation ou la désactivation de la mise en mémoire tampon et ne permettent pas de contrôler sa 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. Définir la propriété `bufferSize` sur une valeur supérieure à 1 activera la mise en mémoire tampon. Une fois le capteur démarré, la propriété bufferSize sera définie sur 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 également 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 indisponibles. Cette fonction renvoie « true » si le capteur est occupé. Vous ne pourrez pas appeler la fonction « start() » sur ce capteur.
Notez que cette fonction ne renvoie pas « true » si vous utilisez le capteur, mais uniquement si un autre processus l'utilise.
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 est connecté à un backend.
Un capteur qui n'est pas 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 n'avez donc besoin de l'appeler que si vous devez 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é contient l'orientation actuelle utilisée pour faire pivoter les valeurs de lecture.
Elle peut ne pas correspondre à l'orientation de l'écran. Par exemple, en mode « FixedOrientation », les valeurs de lecture ne sont pas pivotées ; cette propriété prend donc la valeur 0.
En mode « UserOrientation », les valeurs de mesure sont pivotées en fonction de la propriété « userOrientation » ; cette propriété est donc égale à la propriété « userOrientation ».
En mode « AutomaticOrientation », les valeurs relevées sont pivotées en fonction de l’orientation de l’écran ; cette propriété est 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é définit le débit de données auquel le capteur doit fonctionner.
Elle est exprimée en hertz.
Le débit de données correspond à la fréquence maximale à laquelle le capteur peut détecter des changements.
La configuration de cette propriété n’est pas portable et peut entraîner des conflits avec d’autres applications. Consultez la documentation du backend du capteur et de la plateforme pour connaître les règles applicables lorsque plusieurs applications demandent un débit de données.
La valeur par défaut (0) signifie que l’application ne se soucie pas du débit de données. Les applications doivent envisager d’utiliser une interrogation de la valeur actuelle basée sur une minuterie ou s’assurer que le code traitant les valeurs s’exécute très rapidement, car la plateforme peut fournir des mises à jour plusieurs centaines de fois par seconde.
Ce paramètre doit être défini avant d’appeler la méthode ` start()` car le capteur risque de ne pas détecter les modifications apportées à cette valeur pendant son exécution.
Notez qu’il n’existe aucun mécanisme permettant de déterminer le débit de données actuellement utilisé par la plateforme.
Fonctions d’accès :
| int | dataRate() const |
| void | setDataRate(int rate) |
Signal de notification :
| void | dataRateChanged() |
Voir également QSensor::availableDataRates.
[read-only] description : QString
Cette propriété contient une chaîne de caractères descriptive du capteur.
Fonctions d'accès :
| QString | description() const |
[read-only] efficientBufferSize : int
Cette propriété indique la taille de tampon la plus efficace. En règle générale, cette valeur est égale à 1 (ce qui signifie qu'aucune taille particulière n'est la plus efficace). Certains pilotes de capteurs disposent d'un tampon FIFO, ce qui rend plus efficace la transmission en une seule fois d'un nombre de mesures correspondant à la taille de ce tampon.
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 enregistré sur le capteur.
Notez 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 associé au capteur.
Notez que cet identifiant est renseigné automatiquement lorsque le capteur est connecté à un backend. Si vous souhaitez vous connecter à un backend spécifique, vous devez appeler la méthode `setIdentifier()` avant ` connectToBackend()`.
Fonctions d'accès :
| QByteArray | identifier() const |
| void | setIdentifier(const QByteArray &identifier) |
Signal de notification :
| void | identifierChanged() |
[read-only] maxBufferSize : int
Cette propriété indique la taille maximale de la mémoire tampon.
Notez que cette valeur peut être égale à 1, auquel cas le capteur ne prend en charge aucune forme de mise en mémoire tampon. Dans ce cas, la fonction « isFeatureSupported » (QSensor::Buffering) renverra également la valeur « false ».
Fonctions d'accès :
| int | maxBufferSize() const |
Signal de notification :
| 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 correspond à l'index de la liste « QSensor::outputRanges » à utiliser.
La configuration de cette propriété n’est pas portable et peut entraîner des conflits avec d’autres applications. Consultez la documentation du backend du capteur et de la plateforme pour connaître les règles applicables en cas de demandes de plage de sortie émanant de plusieurs applications.
La valeur par défaut (-1) signifie que l'application ne se soucie 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 également QSensor::outputRanges.
[read-only] outputRanges : qoutputrangelist
Cette propriété contient la liste des plages de sortie prises en charge par le capteur.
Un capteur peut disposer de plusieurs plages de sortie. Cela permet généralement d'obtenir une plage de mesure plus large, au détriment 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 c'est souvent le cas pour les accéléromètres).
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 mesures des capteurs. L'objet de lecture est un cache volatile contenant la mesure la plus récente reçue d'un capteur ; l'application doit donc traiter ces mesures immédiatement ou enregistrer les valeurs quelque part en vue d'un traitement ultérieur.
Notez que cette propriété renvoie 0 tant qu’aucun backend de capteur n’est connecté à un backend.
Notez également que les mesures ne sont pas immédiatement disponibles après l'appel de la fonction ` start()`. Les applications doivent attendre que le signal ` readingChanged()` soit émis.
Fonctions d'accès :
| QSensorReading * | reading() const |
Signal de notification :
| void | readingChanged() |
Voir également isConnectedToBackend() et start().
skipDuplicates : bool
Indique s'il faut omettre les valeurs de mesure en double.
Lorsque l'omission des valeurs en double est activée, les mesures successives dont les valeurs sont identiques ou très similaires sont omises. Cela permet de réduire la charge de traitement, car moins de mesures de capteurs sont mises à disposition. Par conséquent, les mesures arrivent à des intervalles irréguliers.
L'omission des valeurs en double n'est pas seulement activée pour les lectures exactement identiques, mais également pour celles qui sont assez similaires, car chaque capteur présente une légère 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 sur la plate-forme actuelle.
L'ignorance des doublons est désactivée par défaut.
L'ignorance des doublons prend effet au démarrage du capteur ; la modification de cette propriété alors que le capteur est actif n'a aucun 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 du capteur.
Fonctions d'accès :
| QByteArray | type() const |
userOrientation : int
Cette propriété définit l'angle utilisé pour faire pivoter les valeurs de lecture en mode « UserOrientation ».
Lorsque la propriété « axesOrientationMode » est définie sur « UserOrientation », l'angle de rotation des valeurs lues est déterminé par cette propriété. Dans les autres modes, cette propriété n'a aucun effet.
La valeur par défaut est 0. Les seules valeurs valides sont 0, 90, 180 et 270, car ce sont les seules orientations d'écran possibles.
Cette propriété n'est valable que pour les capteurs orientables.
Fonctions d'accès :
| int | userOrientation() const |
| void | setUserOrientation(int userOrientation) |
Signal de notification :
| void | userOrientationChanged(int userOrientation) |
Documentation des fonctions membres
[explicit] QSensor::QSensor(const QByteArray &type, QObject *parent = nullptr)
Construisez le capteur « type » en tant qu'enfant de « parent ».
N'utilisez pas ce constructeur s'il existe une classe dérivée pour le type de capteur spécifique.
La mauvaise façon de procéder 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 disposent de propriétés et de membres de données supplémentaires nécessaires à certaines fonctionnalités, telles que la prise en charge des valeurs géographiques dans QMagnetometer ou la prise en charge du mode accélération dans QAccelerometer. Ces fonctionnalités ne fonctionneront correctement que si vous créez une instance de capteur à partir d’une sous-classe de QSensor.
N’utilisez ce constructeur que s’il n’existe aucune classe de capteur dérivée. Notez que tous les capteurs intégrés disposent d’une classe dérivée ; l’utilisation de ce constructeur ne devrait donc être nécessaire que lors de l’implémentation de capteurs personnalisés.
[virtual noexcept] QSensor::~QSensor()
Détruire le capteur. Arrête le capteur s'il n'est pas déjà arrêté.
[signal] void QSensor::activeChanged()
Ce signal est émis lorsque la propriété « QSensor::active » a changé.
Remarque : signalde notification pour la propriété active.
Voir également QSensor::active.
void QSensor::addFilter(QSensorFilter *filter)
Ajoutez un « filter » au capteur.
Le capteur ne prend pas possession du filtre. L'QSensorFilter informera le capteur si celui-ci est détruit.
Voir aussi QSensorFilter.
[signal] void QSensor::alwaysOnChanged()
Ce signal est émis lorsque la propriété « alwaysOn » change.
Remarque : signalde notification pour la propriété alwaysOn.
[signal] void QSensor::availableSensorsChanged()
Ce signal est émis lorsque la liste des capteurs disponibles a changé. Les capteurs accessibles à un programme ne changent généralement pas au fil du temps ; toutefois, certains d'entre eux peuvent correspondre à du matériel qui n'est pas connecté en permanence. Par exemple, une manette de jeu connectée via Bluetooth deviendrait disponible lorsqu'elle est allumée et 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 permet de « saisir » un capteur dès qu'il devient disponible.
sensor.start();
if (sensor.isBusy()) {
// need to wait for busyChanged signal and try again
}Remarque : signalde notification pour la propriété « busy ».
[invokable] bool QSensor::connectToBackend()
Tente de te connecter à un backend de capteur.
Renvoie « true » si un backend approprié a pu être trouvé, « false » dans le cas contraire.
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 depuis QML. Voir Q_INVOKABLE.
Voir également isConnectedToBackend().
[static] QByteArray QSensor::defaultSensorForType(const QByteArray &type)
Renvoie l'identifiant par défaut du capteur pour type. Celui-ci est défini dans un fichier de configuration et peut être redéfini si nécessaire. Si aucune valeur par défaut n'est disponible, le système renverra le premier capteur enregistré pour type.
Notez qu’il existe une logique particulière visant à empêcher les backends du plugin générique de devenir la valeur par défaut lorsqu’un autre backend est enregistré pour le même type. Cette logique implique qu’un identifiant de backend commençant par generic. ne sera la valeur 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 également Détermination du capteur par défaut pour un type.
QList<QSensorFilter *> QSensor::filters() const
Renvoie les filtres actuellement associé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 Prend en charge une API riche permettant de contrôler les capteurs et de fournir des informations à leur sujet. 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 renverra « false ». L'appel de ` connectToBackend()` ou ` start()` établira une connexion avec le backend.
Les backends doivent implémenter la fonction QSensorBackend::isFeatureSupported() pour que cela fonctionne.
Renvoie si la fonctionnalité est prise en charge lorsque le backend est connecté, ou « false » si le backend n’est pas connecté.
Remarque : cette fonction peut être appelée via le système de méta-objets et depuis QML. Voir Q_INVOKABLE.
[signal] void QSensor::readingChanged()
Ce signal est émis lorsqu'une nouvelle valeur de capteur est reçue.
La valeur mesurée est disponible dans la propriété « QSensor::reading ». Notez que l'objet de mesure est un cache volatile contenant la dernière valeur mesurée reçue ; l'application doit donc traiter cette valeur immédiatement ou enregistrer les valeurs quelque part en vue d'un traitement ultérieur.
Avant que ce signal ne soit émis pour la première fois, l’objet « reading » contiendra des données non initialisées.
Remarque : signalde notification pour la propriété reading.
Voir également start().
void QSensor::removeFilter(QSensorFilter *filter)
Retirez l'filter e du capteur.
Voir également « QSensorFilter ».
[signal] void QSensor::sensorError(int error)
Ce signal est émis lorsqu'un code d'error est activé sur le capteur. Notez que certaines erreurs peuvent entraîner l'arrêt du capteur. Vous devez appeler la fonction isActive() pour vérifier si le capteur fonctionne toujours.
Remarque : signalde 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. S'il n'y a aucun capteur de ce type disponible, la liste sera vide.
void QSensor::setCurrentOrientation(int currentOrientation)
Définit l'orientation actuelle de l'écran sur « currentOrientation ». Cette méthode doit être appelée depuis le backend chaque fois que l'orientation de l'écran ou la propriété « userOrientation » change.
Voir également currentOrientation().
void QSensor::setEfficientBufferSize(int efficientBufferSize)
Définit la taille du tampon efficace à efficientBufferSize. Cette fonction doit être appelée depuis le backend.
Voir également efficientBufferSize().
void QSensor::setMaxBufferSize(int maxBufferSize)
Définit la taille maximale du tampon à maxBufferSize. Cette fonction doit être appelée depuis le backend.
Voir également maxBufferSize().
void QSensor::setSkipDuplicates(bool skipDuplicates)
Définit le paramètre d'ignorance des doublons sur « skipDuplicates ».
Remarque : fonctionde 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 » change.
Remarque : signalde notification pour la propriété skipDuplicates.
[slot] bool QSensor::start()
Commence à récupérer les valeurs du capteur. Renvoie « true » si le capteur a été 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 celui-ci reçoive une nouvelle valeur avant de pouvoir interroger ses valeurs. Cela s'explique par la manière dont le capteur reçoit les valeurs du système. En général, les capteurs n'interrogent pas le système pour obtenir de nouvelles valeurs ; celles-ci leur sont plutôt transmises dès qu'elles sont disponibles.
Par exemple, ce code ne fonctionnera pas comme prévu.
sensor->start();
sensor->reading()->x(); // no data availablePour fonctionner correctement, le code qui accède à la lecture doit s’assurer que le signal ` readingChanged()` a bien é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()
Cesser de récupérer les valeurs du capteur.
Cela libère le capteur afin que d'autres processus puissent l'utiliser.
Voir aussi QSensor::busy.
Éléments associés (non membres)
[alias] qoutputrangelist
Ce type est défini comme une liste de valeurs de type « qoutputrange ».
typedef QList<qoutputrange> qoutputrangelist;Voir également QList, qoutputrange et QSensor::outputRanges.
[alias] qrange
Ce type est défini comme suit : ` QPair`.
typedef QPair<int,int> qrange;Voir également QPair, qrangelist et QSensor::availableDataRates.
[alias] qrangelist
Ce type est défini comme une liste de valeurs qrange.
typedef QList<qrange> qrangelist;Voir également 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.