Positionssensoren

Die Android-Plattform verfügt über zwei Sensoren, mit denen Sie die Position eines Geräts: des Sensors für geomagnetische Felder und des Beschleunigungsmessers. Das Android- verfügt auch über einen Sensor, mit dem Sie feststellen können, ein Gerät mit einem Objekt verbunden ist (als Näherungssensor bezeichnet). Die Der Geomagnetische Feldsensor und der Näherungssensor sind hardwarebasiert. Meiste Hersteller von Mobiltelefonen und Tablets bieten einen Sensor für geomagnetische Felder. Gleichermaßen Hersteller von Mobiltelefonen verwenden in der Regel einen Näherungssensor, um festzustellen, Smartphone nahe an das Gesicht des Nutzers gehalten wird (z. B. während eines Telefons) aufrufen). Um die Ausrichtung eines Geräts zu bestimmen, können Sie die Messwerte den Beschleunigungsmesser des Geräts und den Sensor für geomagnetische Felder.

Hinweis:Der Ausrichtungssensor wurde in Android 2.2 eingestellt. (API-Level 8) und der Ausrichtungssensortyp wurde in Android 4.4W eingestellt. (API-Level 20).

Positionssensoren sind nützlich, um die physische Position eines Geräts Bezugsrahmen der Welt. Sie können beispielsweise das geomagnetische Feld zusammen mit dem Beschleunigungsmesser, um die Position eines Geräts zu bestimmen relativ zum magnetischen Nordpol. Mit diesen Sensoren können Sie auch die Ausrichtung eines Geräts im Bezugsrahmen Ihrer App zu bestimmen. Positionssensoren werden in der Regel nicht zur Überwachung von Gerätebewegungen verwendet. wie Schütteln, Neigen oder Schub. Weitere Informationen finden Sie unter Bewegungssensoren.

Der Sensor für geomagnetische Felder und der Beschleunigungsmesser geben mehrdimensionale Arrays zurück der Sensorwerte für jede SensorEvent. Beispiel: liefert der Sensor für geomagnetische Felder die Werte der geomagnetischen Feldstärke der drei Koordinatenachsen während eines einzelnen Sensorereignisses. Ebenso gilt: misst der Beschleunigungsmesser die Beschleunigung, die auf das Gerät während einer Sensorereignis an. Weitere Informationen zu den verwendeten Koordinatensystemen Sensoren finden Sie unter Sensorkoordinatensysteme. Der Näherungssensor liefert einen einzelnen Wert, für jedes Sensorereignis. In Tabelle 1 sind die Positionssensoren zusammengefasst, auf der Android-Plattform unterstützt.

Tabelle 1 Positionssensoren, die auf der Android-Plattform unterstützt werden.

¹ Dieser Sensor wurde in Android 2.2 (API) eingestellt Level 8) und dieser Sensortyp wurde in Android 4.4W (API-Level 20) eingestellt. Das Sensor-Framework bietet alternative Methoden zum Erfassen eines Geräts Ausrichtung, die in Compute Engine Ausrichtung des Geräts.

² Einige Näherungssensoren liefern nur binäre Werte für Nah und Fern.

Rotationsvektorsensor des Spiels verwenden

Der Rotationsvektorsensor des Spiels ist identisch mit Drehung Vektorsensor unterlegen, außer dass das geomagnetische Feld nicht verwendet wird. Deshalb ist die Y-Achse nicht nach Norden zeigen, sondern auf einen anderen Bezugspunkt verweisen. Dieser Bezug darf sich durch den in der gleichen Größenordnung wie das Gyroskop um die Z-Achse driftet.

Da der Rotationsvektorsensor das Magnetfeld nicht nutzt, sind relative Drehungen genauer sind und nicht von Veränderungen des Magnetfelds beeinflusst werden. Verwende diesen Sensor in einem Spiel, wenn ist es egal, wo Norden liegt, und der normale Rotationsvektor entspricht nicht Ihren Anforderungen. da es vom Magnetfeld abhängig ist.

Der folgende Code zeigt, wie Sie eine Instanz des standardmäßigen Spielerotationsvektors abrufen. Sensor:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR);

Sensor für geomagnetische Rotation verwenden

Der Sensor für geomagnetische Rotationsvektoren ähnelt dem Rotationsvektorsensor, aber wird kein Gyroskop verwendet. Die Genauigkeit dieses Sensors ist geringer als beim normalen Rotationsvektor Sensor reduziert, aber der Stromverbrauch wird reduziert. Verwende diesen Sensor nur, wenn du die Drehung erfassen möchtest ohne zu viel Akkukapazität zu verbrauchen. Dieser Sensor ist am nützlichsten, in Verbindung mit Stapelverarbeitung.

Der folgende Code zeigt, wie Sie eine Instanz der standardmäßigen geomagnetischen Rotation abrufen. Vektorsensor:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR);

Ausrichtung des Geräts berechnen

Durch Berechnung der Ausrichtung eines Geräts können Sie die Position des Geräts Gerät im Verhältnis zum Bezugsrahmen der Erde (insbesondere das magnetische Nordpol). Der folgende Code zeigt, wie Sie die Ausrichtung:

private lateinit var sensorManager: SensorManager
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
val rotationMatrix = FloatArray(9)
SensorManager.getRotationMatrix(rotationMatrix, null, accelerometerReading, magnetometerReading)

// Express the updated rotation matrix as three orientation angles.
val orientationAngles = FloatArray(3)
SensorManager.getOrientation(rotationMatrix, orientationAngles)

private SensorManager sensorManager;
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
final float[] rotationMatrix = new float[9];
SensorManager.getRotationMatrix(rotationMatrix, null,
    accelerometerReading, magnetometerReading);

// Express the updated rotation matrix as three orientation angles.
final float[] orientationAngles = new float[3];
SensorManager.getOrientation(rotationMatrix, orientationAngles);

Das System berechnet die Ausrichtungswinkel mithilfe des geomagnetischen Feldsensor in Kombination mit dem Beschleunigungsmesser des Geräts. Mit diesen beiden Hardwaresensoren liefert das System Daten für die folgenden drei Ausrichtungswinkel:

• Azimut (Drehungsgrade um die -z-Achse) Dies ist den Winkel zwischen der aktuellen Kompassrichtung des Geräts und dem magnetischen Norden. Wenn der obere Rand des Geräts magnetisch nach Norden zeigt, ist der Azimut 0 Grad; Wenn die obere Kante nach Süden zeigt, beträgt der Azimut 180 Grad. In ähnlicher Weise Wenn die obere Kante nach Osten zeigt, beträgt der Azimut 90 Grad und wenn die obere Kante nach Osten zeigt nach Westen zeigt, beträgt der Azimut 270 Grad.
• Neigung (Drehungsgrad um die X-Achse). Dies ist die Winkel zwischen einer Ebene parallel zum Gerätebildschirm und einer parallelen Ebene auf den Boden. Wenn du das Gerät mit der Unterseite parallel zum Boden hältst die Ihnen am nächsten ist, und neigen Sie die Oberseite des Geräts zum Boden. wird der Neigungswinkel positiv. Neigen in die entgegengesetzte Richtung: Wenn Sie die Oberkante des Geräts vom Boden wegbewegen, führt das zu dass der Neigungswinkel negativ wird. Der Wertebereich beträgt -90 Grad bis 90 Grad.
• Neigen (Drehungsgrade um die Y-Achse) Dies ist die Winkel zwischen einer Ebene, die senkrecht zum Bildschirm des Geräts ist, und einer Ebene senkrecht zum Boden. Wenn du das Gerät parallel zum Boden hältst mit der Unterkante, die Ihnen am nächsten ist, und die linke Seite des Geräts neigen Richtung Boden wird der Rollwinkel positiv. In entgegengesetzte Richtung neigen d. h. die rechte Seite des Geräts in Richtung Boden bewegen. führt dazu, dass der Rollwinkel negativ wird. Der Wertebereich beträgt -180 Grad auf 180 Grad stellen.

Hinweis:Die Roll-Definition des Sensors hat sich geändert, um Implementierung im Geosensoren-Ökosystem.

Beachten Sie, dass diese Winkel von einem anderen Koordinatensystem ausgehen einer für die Luftfahrt (Gier-, Nick- und Roll-Richtung). Im Luftfahrtsystem Die x-Achse verläuft entlang der Längsseite des Flugzeugs, vom Heck zur Nase.

Der Ausrichtungssensor bezieht seine Daten aus den Sensorrohdaten. des Beschleunigungsmessers und des Sensors für geomagnetische Felder. Aufgrund des starken Verarbeitung, die Genauigkeit und Präzision der Ausrichtung der Sensor verschlechtert ist. Dieser Sensor ist nur dann zuverlässig, Winkel ist 0. Daher wurde der Ausrichtungssensor in Android eingestellt. 2.2 (API-Level 8) und der Ausrichtungssensortyp in Android wurde eingestellt 4,4 W (API-Level 20) Anstatt Rohdaten des Ausrichtungssensors zu verwenden, empfehlen wir, getRotationMatrix() verwenden in Verbindung mit der getOrientation()-Methode wie im folgenden Codebeispiel gezeigt, um Ausrichtungswerte zu berechnen. Als Teil können Sie die Methode remapCoordinateSystem() -Methode zur Übertragung der Ausrichtungswerte in den Frame Ihrer App Referenz.

class SensorActivity : Activity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private val accelerometerReading = FloatArray(3)
    private val magnetometerReading = FloatArray(3)

    private val rotationMatrix = FloatArray(9)
    private val orientationAngles = FloatArray(3)

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
        // You must implement this callback in your code.
    }

    override fun onResume() {
        super.onResume()

        // Get updates from the accelerometer and magnetometer at a constant rate.
        // To make batch operations more efficient and reduce power consumption,
        // provide support for delaying updates to the application.
        //
        // In this example, the sensor reporting delay is small enough such that
        // the application receives an update before the system checks the sensor
        // readings again.
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)?.also { accelerometer ->
            sensorManager.registerListener(
                    this,
                    accelerometer,
                    SensorManager.SENSOR_DELAY_NORMAL,
                    SensorManager.SENSOR_DELAY_UI
            )
        }
        sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)?.also { magneticField ->
            sensorManager.registerListener(
                    this,
                    magneticField,
                    SensorManager.SENSOR_DELAY_NORMAL,
                    SensorManager.SENSOR_DELAY_UI
            )
        }
    }

    override fun onPause() {
        super.onPause()

        // Don't receive any more updates from either sensor.
        sensorManager.unregisterListener(this)
    }

    // Get readings from accelerometer and magnetometer. To simplify calculations,
    // consider storing these readings as unit vectors.
    override fun onSensorChanged(event: SensorEvent) {
        if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
            System.arraycopy(event.values, 0, accelerometerReading, 0, accelerometerReading.size)
        } else if (event.sensor.type == Sensor.TYPE_MAGNETIC_FIELD) {
            System.arraycopy(event.values, 0, magnetometerReading, 0, magnetometerReading.size)
        }
    }

    // Compute the three orientation angles based on the most recent readings from
    // the device's accelerometer and magnetometer.
    fun updateOrientationAngles() {
        // Update rotation matrix, which is needed to update orientation angles.
        SensorManager.getRotationMatrix(
                rotationMatrix,
                null,
                accelerometerReading,
                magnetometerReading
        )

        // "rotationMatrix" now has up-to-date information.

        SensorManager.getOrientation(rotationMatrix, orientationAngles)

        // "orientationAngles" now has up-to-date information.
    }
}

public class SensorActivity extends Activity implements SensorEventListener {

    private SensorManager sensorManager;
    private final float[] accelerometerReading = new float[3];
    private final float[] magnetometerReading = new float[3];

    private final float[] rotationMatrix = new float[9];
    private final float[] orientationAngles = new float[3];

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
        // You must implement this callback in your code.
    }

    @Override
    protected void onResume() {
        super.onResume();

        // Get updates from the accelerometer and magnetometer at a constant rate.
        // To make batch operations more efficient and reduce power consumption,
        // provide support for delaying updates to the application.
        //
        // In this example, the sensor reporting delay is small enough such that
        // the application receives an update before the system checks the sensor
        // readings again.
        Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        if (accelerometer != null) {
            sensorManager.registerListener(this, accelerometer,
                SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
        }
        Sensor magneticField = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
        if (magneticField != null) {
            sensorManager.registerListener(this, magneticField,
                SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();

        // Don't receive any more updates from either sensor.
        sensorManager.unregisterListener(this);
    }

    // Get readings from accelerometer and magnetometer. To simplify calculations,
    // consider storing these readings as unit vectors.
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
          System.arraycopy(event.values, 0, accelerometerReading,
              0, accelerometerReading.length);
        } else if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
            System.arraycopy(event.values, 0, magnetometerReading,
                0, magnetometerReading.length);
        }
    }

    // Compute the three orientation angles based on the most recent readings from
    // the device's accelerometer and magnetometer.
    public void updateOrientationAngles() {
        // Update rotation matrix, which is needed to update orientation angles.
        SensorManager.getRotationMatrix(rotationMatrix, null,
            accelerometerReading, magnetometerReading);

        // "rotationMatrix" now has up-to-date information.

        SensorManager.getOrientation(rotationMatrix, orientationAngles);

        // "orientationAngles" now has up-to-date information.
    }
}

Normalerweise müssen Sie keine Daten verarbeiten oder filtern. die unbearbeiteten Ausrichtungswinkel des Geräts, mit Ausnahme der Koordinatensystem mit dem Bezugsrahmen Ihrer Anwendung vergleichen.

Geomagnetisches Feldsensor verwenden

Mit dem Sensor für geomagnetische Felder können Änderungen im Magnetfeld der Erde überwacht werden. Die Der folgende Code zeigt, wie Sie eine Instanz des Standardsensors für geomagnetische Felder abrufen:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

Hinweis : Wenn Ihre App auf Android 12 (API-Level 31) oder höher ist, ist dieser Sensor begrenzt.

Dieser Sensor liefert Feldstärke-Rohdaten (in μT) für jede der drei Koordinatenachsen. Normalerweise musst du diesen Sensor nicht direkt verwenden. Stattdessen können Sie den Rotationsvektor um die Drehbewegung zu bestimmen. Sie können auch den Beschleunigungsmesser und das geomagnetische Feld verwenden. in Verbindung mit der getRotationMatrix()-Methode verwenden, um die Rotations- und Neigungsmatrix zu erhalten. Sie können dann diese Matrizen mit dem getOrientation() verwenden und getInclination(), um den Azimut zu erhalten und geomagnetische Neigungsdaten.

Hinweis : Durch das Testen Ihrer App können Sie die Genauigkeit des Sensors, indem Sie das Gerät in einer 8 bewegen.

Nicht kalibriertes Magnetometer verwenden

Das nicht kalibrierte Magnetometer ähnelt dem geomagnetischen Feld , außer dass das Magnetfeld nicht mit Harteisen kalibriert wird. Werkskalibrierung und Temperaturkompensation weiterhin auf das Magnetfeld angewendet werden. Nicht kalibriertes Magnetometer ist bei der Verarbeitung schlechter Schätzungen sehr hilfreich. Im Allgemeinen gilt: geomagneticsensor_event.values[0] wird in der Nähe von uncalibrated_magnetometer_event.values[0] - uncalibrated_magnetometer_event.values[3] liegen. Das heißt:

calibrated_x ~= uncalibrated_x - bias_estimate_x

Hinweis:Nicht kalibrierte Sensoren liefern genauere Ergebnisse und können enthalten eine gewisse Verzerrung, aber ihre Messungen enthalten weniger Sprünge von Korrekturen bis Kalibrierung. Einige Anwendungen bevorzugen diese nicht kalibrierten Ergebnisse als flüssiger und besser zuverlässig sind. Wenn eine Anwendung z. B. versucht, eine eigene Sensorfusion durchzuführen, Kalibrierungen können die Ergebnisse verzerren.

Zusätzlich zum Magnetfeld liefert das nicht kalibrierte Magnetometer die geschätzte Verzerrung durch hartes Eisen in jeder Achse. Der folgende Code zeigt, wie Sie eine Instanz des nicht kalibriertes Standard-Magnetometer:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED);

Näherungssensor verwenden

Mit dem Näherungssensor können Sie ermitteln, wie weit ein Objekt von einem Gerät entfernt ist. Die folgenden zeigt Ihnen, wie Sie eine Instanz des Standard-Näherungssensors abrufen:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);

Der Näherungssensor wird in der Regel verwendet, um zu bestimmen, wie weit der Kopf einer Person vom Gesicht entfernt ist. eines Mobiltelefons (z. B. wenn ein Nutzer einen Anruf tätigt oder entgegennimmt). Meiste Näherungssensoren geben den absoluten Abstand in cm zurück, einige jedoch nur nahe und entfernte Werte.

Hinweis:Bei einigen Gerätemodellen befindet sich der Näherungssensor unterhalb des Bildschirms. Wenn diese Funktion aktiviert ist, während der Bildschirm eingeschaltet ist, kann ein blinkender Punkt auf dem Bildschirm erscheinen. aktiviert.

Der folgende Code zeigt, wie Sie den Näherungssensor verwenden:

class SensorActivity : Activity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private var proximity: Sensor? = null

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)

        // Get an instance of the sensor service, and use that to get an instance of
        // a particular sensor.
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
    }

    override fun onSensorChanged(event: SensorEvent) {
        val distance = event.values[0]
        // Do something with this sensor data.
    }

    override fun onResume() {
        // Register a listener for the sensor.
        super.onResume()

        proximity?.also { proximity ->
            sensorManager.registerListener(this, proximity, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        // Be sure to unregister the sensor when the activity pauses.
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}

public class SensorActivity extends Activity implements SensorEventListener {
    private SensorManager sensorManager;
    private Sensor proximity;

    @Override
    public final void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Get an instance of the sensor service, and use that to get an instance of
        // a particular sensor.
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
    }

    @Override
    public final void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
    }

    @Override
    public final void onSensorChanged(SensorEvent event) {
        float distance = event.values[0];
        // Do something with this sensor data.
    }

    @Override
    protected void onResume() {
        // Register a listener for the sensor.
        super.onResume();
        sensorManager.registerListener(this, proximity, SensorManager.SENSOR_DELAY_NORMAL);
      }

    @Override
    protected void onPause() {
        // Be sure to unregister the sensor when the activity pauses.
        super.onPause();
        sensorManager.unregisterListener(this);
    }
}

Hinweis:Einige Näherungssensoren geben binäre Werte zurück, die „in der Nähe“ oder „weit“. In diesem Fall meldet der Sensor meist seinen maximalen Bereichswert im entfernten Zustand. und ein geringerer Wert im Nahbereich. Üblicherweise ist der Wert weit ein Wert > 5 cm (kann variieren) zwischen Sensor und Sensor. Mit der Methode getMaximumRange() können Sie die maximale Reichweite eines Sensors ermitteln.

Weitere Informationen

• Sensoren
• Sensoren – Übersicht
• Bewegungssensoren
• Umgebungssensoren