Qt Sensors Présentation du C++

Types de capteurs

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

Pour obtenir la liste des types de capteurs intégrés, consultez la section « Classes de capteurs » ci-dessous.

Conventions courantes

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

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

Lorsqu'une rotation autour d'un axe est utilisée, celle-ci doit être exprimée selon la convention de rotation de la main droite.

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

Utilisation d’un capteur

Le cycle de vie d’un « QSensor » est généralement le suivant :

• Créer 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 la réception des valeurs.

Voici un exemple de création d'un capteur dans le tas et dans 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 du capteur de manière générique

La méthode recommandée pour traiter les données des capteurs consiste à utiliser les classes de lecture. Cependant, cela n'est pas toujours possible. Par exemple, vous pouvez être amené à déployer une application sur un appareil équipé d'un nouveau type de capteur, mais pour lequel 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, vous pouvez tout de même accéder aux données des capteurs. Pour ce faire, vous devez disposer de trois informations :

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

Voici par exemple comment accéder à une propriété de l’accéléromètre. Ce code ne nécessite aucun lien 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 lors de l'exécution.

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

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

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

De plus, il est possible de consulter les détails des mesures de ces capteurs, comme illustré ci-dessous :

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

Front-end, Back-end

L'API Qt Sensors comporte un front-end, destiné aux développeurs d'applications, et un back-end, où les développeurs de périphériques é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, même s'il peut être utile de comprendre son fonctionnement.

Les commandes provenant de l’application sont transmises via QSensor, puis acheminées vers le plugin du périphérique. Les données sont renvoyées via la classe QSensorReading.

Vous trouverez plus d’informations sur le backend dans la section « Qt Sensors Backend ».

Classes principales

Les principales classes qui composent l'API d'Qt Sensors.

Classes de lecture

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

Classes de capteurs

Ces classes fournissent des wrappers pratiques qui réduisent le recours au casting. Chacune de ces classes représente un type de capteur reconnu par l’API Qt Sensors. Notez que d’autres types peuvent être disponibles lors de l’exécution. Voir Types de capteurs pour plus d’informations.

Classes de filtrage

Tout comme pour les classes de capteurs, celles-ci fournissent des wrappers pratiques qui réduisent le recours au casting.