Qt Sensors C++ Überblick

Sensor-Typen

Auf einem Gerät kann es viele Arten von Sensoren geben. Möglicherweise sind nicht alle von der Qt Sensors API unterstützten Typen verfügbar. Es können auch Typen vorhanden sein, die nicht in der Qt Sensors API definiert sind. Die auf einem Gerät verfügbaren Sensortypen werden mit der Funktion QSensor::sensorTypes() ermittelt.

Eine Liste der eingebauten Sensortypen finden Sie im Abschnitt " Sensorklassen " weiter unten.

Allgemeine Konventionen

Wenn nicht anders angegeben, verwendet Qt Sensors das kartesische Rechtskoordinatensystem.

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

Wird eine Drehung um eine Achse verwendet, so ist die Drehung 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 mit der rechten Seite nach oben erscheint). Wenn die Werte auf dem Bildschirm angezeigt werden sollen, müssen sie möglicherweise so transformiert werden, dass sie mit der Ausrichtung der Benutzeroberfläche übereinstimmen. Ein Sensor kann seine Daten so definieren, dass sie an der Benutzeroberfläche ausgerichtet sind. Dies wird in der Dokumentation für den Sensor vermerkt.

Einen Sensor verwenden

Der Lebenszyklus eines QSensor ist typisch:

• Erstellen einer Instanz von QSensor oder einer seiner Unterklassen auf dem Stack oder Heap.
• Einrichten wie von der Anwendung benötigt.
• Beginn des Empfangs von Werten.
• Sensordaten werden von der Anwendung verwendet.
• Beenden Sie den Empfang von Werten.

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

Zugriff auf Sensordaten in einer generischen Weise

Der bevorzugte Weg, mit Sensordaten umzugehen, ist über die Leseklassen. Manchmal ist dies jedoch nicht möglich. Sie können zum Beispiel eine Anwendung auf einem Gerät einsetzen, das einen neuen Sensortyp hat, aber es ist kein C++-Header verfügbar, der die Leseklasse beschreibt.

Dank des Eigenschaftssystems von Qt können Sie dennoch auf die Sensordaten zugreifen. Dazu müssen Sie 3 Informationen kennen:

• Den Sensortyp.
• Der Eigenschaftsname oder Index.
• Den Typ der Eigenschaft oder einen vergleichbaren Typ.

Hier ein Beispiel, wie Sie auf eine Eigenschaft des Beschleunigungssensors zugreifen können. Für diesen Code sind keine Kompilierzeit-Links zu QAccelerometer oder QAccelerometerReading erforderlich.

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

Sie können all diese Informationen auch zur Laufzeit abrufen.

Erkennung von Sensoren und Lesen von Eigenschaften zur Laufzeit

Manchmal kann es vorkommen, dass die verfügbaren Sensoren zur Entwicklungszeit nicht bekannt sind. Es ist möglich, herauszufinden, welche Sensoren verfügbar sind, wie unten dargestellt:

QList<QSensor*> mySensorList;for(const QByteArray &type: QSensor::sensorTypes()) {    qDebug() << "Found a sensor type:" << type;
   for(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); } }

Darüber hinaus ist es möglich, die Messdaten dieser Sensoren zu ermitteln, wie unten dargestellt:

for (QSensor* sensor : mySensorList) { const int firstProperty = QSensorReading::staticMetaObject.propertyOffset(); // Zuerst mit Backend verbinden, 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 hat ein Frontend, das von Anwendungsentwicklern genutzt werden kann, und ein Backend, in dem Geräteimplementierer Code für den Zugriff auf ihre Hardware schreiben. Als Anwendungsentwickler müssen Sie nicht auf das Back-End zugreifen, obwohl es nützlich sein kann, dessen Funktionsweise zu verstehen.

Befehle aus der Anwendung werden über QSensor an das Geräte-Plugin weitergeleitet. Die Daten kommen über die Klasse QSensorReading zurück.

Weitere Informationen über das Backend finden Sie unter Qt Sensors Backend.

Hauptklassen

Die Hauptklassen, aus denen die Qt Sensors API besteht.

Lesende Klassen

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

Sensor-Klassen

Diese Klassen bieten komfortable Wrapper, die die Notwendigkeit des Castings reduzieren. Jede dieser Klassen repräsentiert einen Sensortyp, der der Qt Sensors API bekannt ist. Beachten Sie, dass zusätzliche Typen zur Laufzeit verfügbar gemacht werden können. Siehe Sensortypen für weitere Informationen.

Filter-Klassen

Wie bei den Sensorklassen sind auch hier Convenience Wrapper vorhanden, die den Bedarf an Casting reduzieren.