Qt Sensors C++ – Überblick

Sensortypen

Auf einem Gerät können viele verschiedene Sensortypen vorhanden sein. Möglicherweise sind nicht alle Typen verfügbar, die von der API „ Qt Sensors “ unterstützt werden. Es können auch Typen verfügbar sein, die nicht in der API „ Qt Sensors “ definiert sind. Die auf einem Gerät verfügbaren Sensortypen lassen sich mit der Funktion „ QSensor::sensorTypes()“ ermitteln.

Eine Liste der integrierten Sensortypen finden Sie im Abschnitt „Sensor-Klassen“ weiter unten.

Allgemeine Konventionen

Sofern nicht anders angegeben, verwendet „ Qt Sensors “ das rechtshändige kartesische Koordinatensystem.

Um Messungen in allen 6 Richtungen zu ermöglichen, werden negative Werte verwendet.

Wird eine Drehung um eine Achse verwendet, ist diese als Rechtsdrehung auszudrücken.

Im Allgemeinen sind die Sensordaten relativ zu „ QScreen::nativeOrientation “ ausgerichtet, d. h. zur Oberseite des Geräts, wenn dieses in seiner natürlichen Ausrichtung gehalten wird (normalerweise, wenn das Gerätelogo richtig herum zu sehen ist). Sollen Werte auf dem Bildschirm angezeigt werden, müssen diese möglicherweise so transformiert werden, dass sie der Ausrichtung der Benutzeroberfläche entsprechen. Ein Sensor kann seine Daten so definieren, dass sie auf die Benutzeroberfläche ausgerichtet sind. Dies wird in der Dokumentation des Sensors vermerkt.

Verwendung eines Sensors

Der Lebenszyklus eines „ QSensor “ verläuft typischerweise wie folgt:

• Erstellen Sie eine Instanz von ` QSensor ` oder einer seiner Unterklassen auf dem Stack oder dem Heap.
• Konfigurieren Sie den Sensor entsprechend den Anforderungen der Anwendung.
• Beginnen Sie mit dem Empfang von Werten.
• Die Sensordaten werden von der Anwendung verwendet.
• Beenden Sie den Empfang von Werten.

Hier ist ein Beispiel für die Erstellung eines Sensors auf dem Heap und auf dem Stack.

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

Generischer Zugriff auf Sensordaten

Die bevorzugte Methode zum Umgang mit Sensordaten ist die Verwendung der Leseklassen. Manchmal ist dies jedoch nicht möglich. Beispielsweise stellen Sie möglicherweise eine Anwendung auf einem Gerät bereit, das über einen neuen Sensortyp verfügt, für den jedoch kein C++-Header zur Beschreibung der Leseklasse verfügbar ist.

Dank des Eigenschaftssystems von Qt können Sie dennoch auf die Sensordaten zugreifen. Dazu benötigen Sie drei Informationen:

• Den Sensortyp.
• Den Eigenschaftsnamen oder -index.
• Den Eigenschaftstyp oder einen vergleichbaren Typ.

Hier ist beispielsweise ein Beispiel dafür, wie Sie auf eine Eigenschaft des Beschleunigungssensors zugreifen können. Dieser Code erfordert keine Verknüpfungen zur Kompilierungszeit zu QAccelerometer oder 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>();

All diese Informationen können Sie auch zur Laufzeit ermitteln.

Sensoren erkennen und Eigenschaften zur Laufzeit auslesen

Manchmal kann es vorkommen, dass die verfügbaren Sensoren zum Zeitpunkt der Entwicklung noch nicht bekannt sind. Wie unten dargestellt, lässt sich herausfinden, welche Sensoren verfügbar sind:

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

Darüber hinaus ist es möglich, die Messwerte dieser Sensoren abzurufen, wie im Folgenden dargestellt:

for (QSensor* sensor : mySensorList) {
    const int firstProperty = QSensorReading::staticMetaObject.propertyOffset();
    // Zuerst eine Verbindung zum Backend herstellen, falls `start()` noch nicht aufgerufen wurde
    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();
        }
    }
}

Frontend, Backend

Die Qt Sensors -API verfügt über ein Frontend, das von Anwendungsentwicklern genutzt wird, und ein Backend, in dem Geräteentwickler Code schreiben, um auf ihre Hardware zuzugreifen. Als Anwendungsentwickler müssen Sie zwar nicht auf das Backend zugreifen, es kann jedoch hilfreich sein, dessen Funktionsweise zu verstehen.

Befehle aus der Anwendung werden über „ QSensor “ an das Geräte-Plugin weitergeleitet. Daten werden über die Klasse „ QSensorReading “ zurückgegeben.

Weitere Informationen zum Backend finden Sie unter „Qt Sensors Backend“.

Hauptklassen

Die wichtigsten Klassen, aus denen sich die Qt Sensors -API zusammensetzt.

Leseklassen

Der beste Weg, auf Sensordaten zuzugreifen, ist über eine dieser Klassen.

Sensor-Klassen

Diese Klassen bieten praktische Wrapper, die den Bedarf an Typumwandlungen reduzieren. Jede dieser Klassen repräsentiert einen Sensortyp, den die „ Qt Sensors “-API kennt. Beachten Sie, dass zur Laufzeit möglicherweise weitere Typen verfügbar sind. Weitere Informationen finden Sie unter „Sensortypen “.

Filterklassen

Wie bei den Sensor-Klassen bieten diese Komfort-Wrapper, die das Typumwandeln überflüssig machen.