Qt Sensors Vue d'ensemble du C++

Types de capteurs

Un appareil peut comporter de nombreux types de capteurs. Tous les types pris en charge par l'API Qt Sensors peuvent ne pas être disponibles. Il peut également y avoir des types disponibles qui ne sont pas définis dans l'API Qt Sensors. Les types de capteurs disponibles sur un appareil sont déterminés à l'aide de la fonction QSensor::sensorTypes().

Pour une liste des types de capteurs intégrés, voir la section Classes de capteurs ci-dessous.

Conventions communes

Sauf indication contraire, Qt Sensors utilise le système de coordonnées cartésiennes de la main droite.

Pour permettre des mesures dans les 6 directions, des valeurs négatives sont utilisées.

Lorsque la rotation autour d'un axe est utilisée, la rotation doit être exprimée comme une rotation à droite.

En général, les données des capteurs sont orientées par rapport à QScreen::nativeOrientation, c'est-à-dire par rapport au haut de l'appareil lorsque celui-ci est tenu dans son orientation naturelle (normalement lorsque le logo de l'appareil apparaît à l'endroit). Si les valeurs doivent être affichées à l'écran, il peut être nécessaire de les transformer pour qu'elles correspondent à l'orientation de l'interface utilisateur. Un capteur peut définir ses données comme étant orientées vers l'interface utilisateur. Cela sera indiqué dans la documentation du capteur.

Utilisation d'un capteur

Le cycle de vie d'un site QSensor est généralement le suivant :

• Création d'une instance de QSensor ou de l'une de ses sous-classes 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êtez de recevoir des valeurs.

Voici un exemple de création d'un capteur sur le tas et sur la pile.

// On the heap (deleted when this object is deleted)
QAccelerometer *sensor = new QAccelerometer(this);

// On the stack (deleted when the current scope ends)
QOrientationSensor orient_sensor;

Accès aux données des capteurs de manière générique

La meilleure façon de traiter les données des capteurs est d'utiliser les classes de lecture. Cependant, il arrive que cela ne soit pas possible. Par exemple, vous pouvez déployer une application sur un appareil doté d'un nouveau type de capteur, mais aucun en-tête C++ décrivant la classe de lecture n'est disponible.

Grâce au système de propriétés de Qt Sensors, vous pouvez toujours accéder aux données du capteur. Pour ce faire, vous devez connaître trois éléments d'information :

• Le type de capteur.
• Le nom ou l'index de la propriété.
• Le type de propriété ou un type comparable.

Par exemple, voici un exemple de la manière dont vous pouvez accéder à une propriété de l'accéléromètre. Ce code ne nécessite pas de liens de compilation vers QAccelerometer ou QAccelerometerReading.

// start the sensor
QSensor sensor("QAccelerometer");
sensor.start();

// later
QSensorReading *reading = sensor.reading();
qreal x = reading->property("x").value<qreal>();
qreal y = reading->value(1).value<qreal>();

Vous pouvez également découvrir toutes ces informations au moment de l'exécution.

Découverte des capteurs et lecture des propriétés à l'exécution

Il peut arriver que les capteurs disponibles ne soient pas connus au moment du développement. Il est possible de découvrir quels sont les capteurs disponibles, comme illustré ci-dessous :

QList<QSensor*> mySensorList ;for(const QByteArray &type: QSensor::sensorTypes()) {    qDebug() << "Found a sensor type:" << type;
   pour(const QByteArray &identifier: QSensor::sensorsForType(type)) {        qDebug() << "    " << "Found a sensor of that type:" << identifier;
        QSensor* sensor = new QSensor(type, this) ;  sensor->setIdentifier(identifier) ; mySensorList.append(sensor) ; } }

En outre, il est possible de découvrir les détails de la lecture de ces capteurs, comme illustré ci-dessous :

for (QSensor* sensor : mySensorList) { const int firstProperty = QSensorReading::staticMetaObject.propertyOffset() ; // Se connecter d'abord au backend au cas où start() n'aurait pas encore été appelé if (!sensor->connectToBackend()) continue;    qDebug() << "Sensor" << sensor->identifier() << "reading properties:";
    QSensorReading *reading =  sensor->reading() ; if (reading) { const QMetaObject *mo =  reading->metaObject() ; for(int i = firstProperty ; i <  mo->propertyCount() ; ++i) { QByteArray name =  mo->property(i).name() ;            qDebug() << "    " << name << reading->property(name).toByteArray();
        } } }

Front End, Back End

L'API Qt Sensors comporte une partie frontale, que les développeurs d'applications peuvent utiliser, et une partie dorsale, où les implémenteurs d'appareils écrivent du code pour accéder à leur matériel. En tant que développeur d'applications, vous n'avez pas besoin d'accéder au back-end, mais il peut être utile d'en comprendre le fonctionnement.

Les commandes de l'application sont transmises par l'intermédiaire de QSensor et descendent jusqu'au plugin de l'appareil. Les données sont renvoyées par la classe QSensorReading.

Vous trouverez plus d'informations sur le back-end à l'adresseQt Sensors Backend.

Classes principales

Les classes principales qui constituent l'API Qt Sensors.

Classes de lecture

La meilleure façon d'accéder aux données d'un capteur est d'utiliser l'une de ces classes.

Classes de capteurs

Ces classes fournissent des enveloppes de commodité qui réduisent le besoin de moulage. Chacune de ces classes représente un type de capteur connu de l'API Qt Sensors. Notez que des types supplémentaires peuvent être mis à disposition lors de l'exécution. Voir Types de capteurs pour plus d'informations.

Classes de filtres

Comme pour les classes de capteurs, ces classes fournissent des enveloppes de commodité qui réduisent le besoin de moulage.