แพลตฟอร์ม Android มีเซ็นเซอร์ 2 ตัวที่ช่วยให้คุณกำหนดตำแหน่ง ของอุปกรณ์ ได้แก่ เซ็นเซอร์สนามแม่เหล็กและตัวตรวจวัดความเร่ง Android แพลตฟอร์มของแพลตฟอร์มยังมีเซ็นเซอร์ที่ให้คุณระบุระยะห่างของใบหน้าของ อุปกรณ์หมายถึงวัตถุ (หรือที่เรียกว่าพร็อกซิมิตีเซ็นเซอร์) เซ็นเซอร์สนามแม่เหล็กและพร็อกซิมิตีเซ็นเซอร์ทำงานด้วยฮาร์ดแวร์ พบบ่อยที่สุด ผู้ผลิตโทรศัพท์มือถือและแท็บเล็ตมีเซ็นเซอร์สนามแม่เหล็กโลก ในทำนองเดียวกัน โดยปกติแล้วผู้ผลิตโทรศัพท์มือถือจะมีพร็อกซิมิตีเซ็นเซอร์เพื่อระบุว่า ถือโทรศัพท์ไว้ใกล้ใบหน้าของผู้ใช้ (เช่น ขณะใช้โทรศัพท์ การโทร) สำหรับการกำหนดการวางแนวของอุปกรณ์ คุณสามารถใช้ค่าที่อ่านได้จาก ตัวตรวจวัดความเร่งของอุปกรณ์และเซ็นเซอร์สนามแม่เหล็กโลก
หมายเหตุ: เซ็นเซอร์การวางแนวได้รับการเลิกใช้งานแล้วใน Android 2.2 (API ระดับ 8) และเลิกใช้งานประเภทเซ็นเซอร์การวางแนวใน Android 4.4W (API ระดับ 20)
เซ็นเซอร์ตำแหน่งมีประโยชน์ในการระบุตำแหน่งทางกายภาพของอุปกรณ์ใน กรอบอ้างอิงของโลกได้ ตัวอย่างเช่น คุณสามารถใช้สนามแม่เหล็กโลก เซ็นเซอร์ร่วมกับตัวตรวจวัดความเร่งเพื่อกำหนดตำแหน่งของอุปกรณ์ เมื่อเทียบกับขั้วโลกเหนือแม่เหล็ก และคุณยังใช้เซ็นเซอร์เหล่านี้เพื่อ กำหนดการวางแนวของอุปกรณ์ในกรอบอ้างอิงของแอปพลิเคชันของคุณ เซ็นเซอร์ตำแหน่งมักจะไม่ได้ใช้เพื่อตรวจสอบการเคลื่อนไหวหรือการเคลื่อนไหวของอุปกรณ์ เช่น สั่น เอียง หรือขับดัน (ดูข้อมูลเพิ่มเติมได้ที่เซ็นเซอร์ตรวจจับการเคลื่อนไหว)
เซ็นเซอร์สนามแม่เหล็กและตัวตรวจวัดความเร่งจะแสดงผลอาร์เรย์หลายมิติ
ของค่าเซ็นเซอร์สำหรับ SensorEvent
แต่ละรายการ ตัวอย่างเช่น
เซ็นเซอร์สนามแม่เหล็กมีค่าความแรงของสนามแม่เหล็กโลกสำหรับ
แกนพิกัดแต่ละแกนจากทั้ง 3 แกนในระหว่างเหตุการณ์เซ็นเซอร์ครั้งเดียว ในทำนองเดียวกัน
เซ็นเซอร์ตัวตรวจวัดความเร่งวัดความเร่งที่ใช้กับอุปกรณ์ระหว่าง
เหตุการณ์เซ็นเซอร์ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับระบบพิกัดที่ใช้
ตามเซ็นเซอร์ โปรดดู
ระบบพิกัดเซ็นเซอร์ พร็อกซิมิตีเซ็นเซอร์มีค่าเดียว
สำหรับแต่ละเหตุการณ์เซ็นเซอร์ ตารางที่ 1 สรุปตำแหน่งเซ็นเซอร์ที่
ที่ได้รับการสนับสนุนบนแพลตฟอร์ม Android
ตาราง 1 เซ็นเซอร์ตำแหน่งที่แพลตฟอร์ม Android รองรับ
เซ็นเซอร์ | ข้อมูลเหตุการณ์เซ็นเซอร์ | คำอธิบาย | หน่วยวัด |
---|---|---|---|
TYPE_GAME_ROTATION_VECTOR |
SensorEvent.values[0] |
องค์ประกอบเวกเตอร์การหมุนตามแกน x (x * sin(CONFIRM/2)) | ไม่มีหน่วย |
SensorEvent.values[1] |
องค์ประกอบเวกเตอร์การหมุนตามแกน y (y * sin(CONFIRM/2)) | ||
SensorEvent.values[2] |
คอมโพเนนต์เวกเตอร์การหมุนตามแกน z (z * sin(การเป็นสมาชิก/2)) | ||
TYPE_GEOMAGNETIC_ROTATION_VECTOR |
SensorEvent.values[0] |
องค์ประกอบเวกเตอร์การหมุนตามแกน x (x * sin(CONFIRM/2)) | ไม่มีหน่วย |
SensorEvent.values[1] |
องค์ประกอบเวกเตอร์การหมุนตามแกน y (y * sin(CONFIRM/2)) | ||
SensorEvent.values[2] |
คอมโพเนนต์เวกเตอร์การหมุนตามแกน z (z * sin(การเป็นสมาชิก/2)) | ||
TYPE_MAGNETIC_FIELD |
SensorEvent.values[0] |
ความแรงของสนามแม่เหล็กโลกตามแกน x | ไมครอน |
SensorEvent.values[1] |
ความแรงของสนามแม่เหล็กโลกตามแกน Y | ||
SensorEvent.values[2] |
ความแรงของสนามแม่เหล็กโลกตามแกน Z | ||
TYPE_MAGNETIC_FIELD_UNCALIBRATED |
SensorEvent.values[0] |
ความแรงของสนามแม่เหล็กโลก (ไม่มีการปรับเทียบเหล็กแข็ง) ตามแกน x | ไมครอน |
SensorEvent.values[1] |
ความแรงของสนามแม่เหล็กโลก (ไม่มีการปรับเทียบเหล็กแข็ง) ตามแกน Y | ||
SensorEvent.values[2] |
ความแรงของสนามแม่เหล็กโลก (ไม่มีการปรับเทียบเหล็กแข็ง) ตามแกน Z | ||
SensorEvent.values[3] |
การประมาณการให้น้ำหนักพิเศษเหล็กตามแกน x | ||
SensorEvent.values[4] |
การประมาณค่าอคติเหล็กตามแกน Y | ||
SensorEvent.values[5] |
การประมาณการให้น้ำหนักพิเศษเหล็กตามแกน z | ||
TYPE_ORIENTATION 1 |
SensorEvent.values[0] |
แอซิมัท (มุมรอบแกน z) | องศา |
SensorEvent.values[1] |
ระดับความสูงต่ำ (ทำมุมรอบแกน x) | ||
SensorEvent.values[2] |
หมุน (ทำมุมรอบแกน Y) | ||
TYPE_PROXIMITY |
SensorEvent.values[0] |
ระยะห่างจากวัตถุ2 | ซม. |
1เซ็นเซอร์นี้เลิกใช้งานแล้วใน Android 2.2 (API ระดับ 8) และได้เลิกใช้งานเซ็นเซอร์ประเภทนี้ใน Android 4.4W (API ระดับ 20) แล้ว เฟรมเวิร์กเซ็นเซอร์แสดงวิธีการทางเลือกในการรับอุปกรณ์ ซึ่งจะกล่าวถึงในการประมวลผล การวางแนวของอุปกรณ์
2 พร็อกซิมิตีเซ็นเซอร์บางรุ่นจะระบุค่าไบนารีเท่านั้น แสดงถึงระยะใกล้และไกล
ใช้เซ็นเซอร์เวกเตอร์การหมุนเกม
เซ็นเซอร์เวกเตอร์การหมุนเกม เหมือนกับ การหมุน เซ็นเซอร์เวกเตอร์ ยกเว้นว่าไม่ได้ใช้สนามแม่เหล็กโลก ดังนั้นแกน Y จะไม่ ชี้ไปทางทิศเหนือ แต่ชี้ไปที่การอ้างอิงอื่นๆ แทน การอ้างอิงดังกล่าวได้รับอนุญาตให้ลอยตาม ซึ่งมีลำดับขนาดเท่ากับเครื่องวัดการหมุนจะลอยรอบแกน Z
เนื่องจากเซ็นเซอร์เวกเตอร์การหมุนเกมไม่ได้ใช้สนามแม่เหล็ก การหมุนแบบสัมพัทธ์ มีความถูกต้องมากขึ้น และไม่ได้รับผลกระทบจากการเปลี่ยนแปลงสนามแม่เหล็ก ใช้เซ็นเซอร์นี้ในเกม หาก คุณไม่สนใจว่าทิศเหนืออยู่ตรงไหน และเวกเตอร์การหมุนปกติไม่ตรงกับความต้องการของคุณ เพราะต้องพึ่งพาสนามแม่เหล็ก
โค้ดต่อไปนี้แสดงวิธีขอรับอินสแตนซ์ของเวกเตอร์การหมุนเริ่มต้นของเกม เซ็นเซอร์:
Kotlin
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)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR);
ใช้เซ็นเซอร์เวกเตอร์การหมุนแม่เหล็กภูมิศาสตร์
เซ็นเซอร์เวกเตอร์การหมุนแม่เหล็กทางภูมิศาสตร์คล้ายกับ เซ็นเซอร์เวกเตอร์การหมุน แต่ ก็ไม่ใช้เครื่องวัดการหมุน ความแม่นยำของเซ็นเซอร์นี้ต่ำกว่าเวกเตอร์การหมุนปกติ เซ็นเซอร์ แต่การใช้พลังงานลดลง ใช้เซ็นเซอร์นี้ต่อเมื่อต้องการรวบรวมการหมุนเท่านั้น ข้อมูลในเบื้องหลังโดยไม่ต้องใช้แบตเตอรี่มากเกินไป เซ็นเซอร์นี้มีประโยชน์มากที่สุดเมื่อใช้ ร่วมกับการทำงานแบบกลุ่ม
โค้ดต่อไปนี้แสดงวิธีขอรับอินสแตนซ์ของการหมุนแม่เหล็กเริ่มต้น เซ็นเซอร์เวกเตอร์:
Kotlin
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)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR);
คำนวณการวางแนวของอุปกรณ์
ด้วยการคำนวณการวางแนวของอุปกรณ์ คุณสามารถตรวจสอบตำแหน่งของ ที่สัมพันธ์กับกรอบอ้างอิงของโลก (โดยเฉพาะอย่างยิ่ง แม่เหล็กไฟฟ้า ขั้วโลกเหนือ) รหัสต่อไปนี้แสดงวิธีการคำนวณ การวางแนว:
Kotlin
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)
Java
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);
ระบบจะคำนวณมุมการวางแนวโดยใช้คลื่นแม่เหล็กของอุปกรณ์ เซ็นเซอร์สนามร่วมกับตัวตรวจวัดความเร่งของอุปกรณ์ การใช้ 2 อย่างนี้ เซ็นเซอร์ของฮาร์ดแวร์ ระบบจะให้ข้อมูลสำหรับ 3 สิ่งต่อไปนี้ มุมการวางแนว:
- แอซิมัท (องศาการหมุนเกี่ยวกับแกน -z) นี่คือ มุมระหว่างทิศทางเข็มทิศปัจจุบันของอุปกรณ์และทิศเหนือของแม่เหล็ก หากขอบด้านบนของอุปกรณ์หันไปทางทิศเหนือของแม่เหล็ก แอซิมัทจะเท่ากับ 0 องศา; ถ้าขอบด้านบนหันไปทางทิศใต้ แอซิมัทจะเป็น 180 องศา ในทำนองเดียวกัน ถ้าขอบด้านบนหันไปทางทิศตะวันออก แอซิมัทจะเท่ากับ 90 องศา และถ้าขอบบน หันหน้าไปทางทิศตะวันตก ส่วนแอซิมัทอยู่ที่ 270 องศา
- ระดับเสียง (องศาการหมุนเกี่ยวกับแกน x) นี่คือ มุมระหว่างระนาบที่ขนานกับหน้าจอของอุปกรณ์กับระนาบขนาน ลงด้านล่าง หากคุณถืออุปกรณ์ให้ขนานกับพื้นโดยมีด้านล่างอยู่ ให้ขอบใกล้กับคุณมากที่สุด และเอียงขอบด้านบนของอุปกรณ์ไปที่พื้น มุมระดับเสียงจะเป็นบวก การเอียงในทิศทางตรงกันข้าม ย้ายขอบด้านบนของอุปกรณ์ออกห่างจากพื้น ซึ่งทำให้เกิด มุมระดับความสูงต่ำจะกลายเป็นค่าลบ ช่วงของค่าคือ -90 องศา ถึง 90 องศา
- หมุน (องศาการหมุนเกี่ยวกับแกน Y) นี่คือ มุมระหว่างระนาบตั้งฉากกับหน้าจออุปกรณ์และระนาบ ตั้งฉากกับพื้น หากคุณถืออุปกรณ์ให้ขนานกับพื้น โดยให้ขอบด้านล่างอยู่ใกล้คุณที่สุดและเอียงขอบด้านซ้ายของอุปกรณ์ ไปทางพื้น มุมการกลิ้งจะกลายเป็นค่าบวก การเอียงในตรงกันข้าม การเปลี่ยนขอบด้านขวาของอุปกรณ์ไปที่พื้น จะทำให้มุมการหมุนเป็นค่าลบ ช่วงของค่าคือ -180 องศา เป็น 180 องศา
หมายเหตุ: คำจำกัดความการม้วนของเซ็นเซอร์มีการเปลี่ยนแปลงเพื่อแสดง การใช้งานส่วนใหญ่ในระบบนิเวศ Geoเซ็นเซอร์
โปรดสังเกตว่ามุมเหล่านี้ทำงานที่ระบบพิกัดต่างจากระบบพิกัด ใช้ในการบิน (สำหรับการเอียง ระดับเสียงสูง และการหมุน) ในระบบการบิน แกน x ตามแนวยาวของระนาบ ตั้งแต่หางไปจนถึงจมูก
เซ็นเซอร์ตรวจจับการวางแนวดึงข้อมูลมาจากการประมวลผลข้อมูลดิบของเซ็นเซอร์
จากตัวตรวจวัดความเร่งและเซ็นเซอร์สนามแม่เหล็กโลก เนื่องจากอัตรา
การประมวลผลที่เกี่ยวข้อง ตลอดจนความแม่นยำและความแม่นยำของการวางแนว
เซ็นเซอร์ลดลง เซ็นเซอร์นี้เชื่อถือได้เฉพาะเวลาที่หมุน
มุมเท่ากับ 0 ด้วยเหตุนี้ ระบบจึงเลิกใช้งานเซ็นเซอร์การวางแนวใน Android
2.2 (API ระดับ 8) และเลิกใช้งานประเภทเซ็นเซอร์การวางแนวใน Android
4.4W (API ระดับ 20)
แทนที่จะใช้ข้อมูลดิบจากเซ็นเซอร์การวางแนว เราขอแนะนำให้คุณ
ใช้ getRotationMatrix()
ร่วมกับ
getOrientation()
วิธี
เพื่อคำนวณค่าการวางแนวดังที่แสดงในตัวอย่างโค้ดต่อไปนี้ เป็นส่วนหนึ่งของ
ของกระบวนการนี้ คุณสามารถใช้
remapCoordinateSystem()
วิธีการแปลค่าการวางแนวเป็นเฟรมของแอปพลิเคชันของคุณ
ข้อมูลอ้างอิง
Kotlin
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. } }
Java
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. } }
โดยปกติแล้วคุณไม่จำเป็นต้องประมวลผลข้อมูลหรือกรองข้อมูล มุมการวางแนวของอุปกรณ์ดิบนอกเหนือจากการแปลเซ็นเซอร์ กับกรอบอ้างอิงของแอปพลิเคชันของคุณ
ใช้เซ็นเซอร์สนามแม่เหล็กโลก
เซ็นเซอร์สนามแม่เหล็กโลกช่วยให้คุณสามารถตรวจสอบการเปลี่ยนแปลงของสนามแม่เหล็กของโลกได้ โค้ดต่อไปนี้แสดงวิธีขอรับอินสแตนซ์ของเซ็นเซอร์สนามแม่เหล็กที่เป็นค่าเริ่มต้น
Kotlin
private lateinit var sensorManager: SensorManager private var sensor: Sensor? = null ... sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
หมายเหตุ: หากแอปกำหนดเป้าหมายเป็น Android 12 (API ระดับ 31) หรือ สูงกว่า เซ็นเซอร์นี้ ถูกจำกัดอัตรา
เซ็นเซอร์นี้ให้ข้อมูลความแรงของสนามแบบดิบ (ในหน่วย μT) สำหรับแกนพิกัดแต่ละแกน
โดยปกติแล้ว คุณไม่จำเป็นต้องใช้เซ็นเซอร์นี้โดยตรง คุณสามารถใช้เวกเตอร์การหมุนแทนได้
เซ็นเซอร์สำหรับระบุการเคลื่อนที่แบบข้อมูลดิบ หรือคุณสามารถใช้ตัวตรวจวัดความเร่งและสนามแม่เหล็กโลก
เซ็นเซอร์ร่วมกับเมธอด getRotationMatrix()
เพื่อดูเมทริกซ์การหมุนและเมทริกซ์ความเอียง จากนั้นคุณจะสามารถ
ให้ใช้เมทริกซ์เหล่านี้กับ getOrientation()
และ getInclination()
วิธีในการขอรับแอซิมัท
และข้อมูลความเอียงของแม่เหล็กโลก
หมายเหตุ: เมื่อทดสอบแอป คุณสามารถปรับปรุง ความแม่นยำของเซ็นเซอร์โดยโบกอุปกรณ์ในรูปแบบรูปเลข 8
ใช้เครื่องวัดค่าความเข้มข้นของสนามแม่เหล็กที่ไม่ได้ปรับเทียบ
เครื่องวัดค่าความเข้มข้นของสนามแม่เหล็กที่ไม่ได้รับการปรับจะเหมือนกับสนามแม่เหล็กโลก
เซ็นเซอร์ ยกเว้นในกรณีที่ไม่มีการปรับเทียบเหล็กแข็งกับสนามแม่เหล็ก การปรับเทียบจากโรงงาน
และการชดเชยอุณหภูมิจะยังคงมีผลกับสนามแม่เหล็ก เครื่องวัดค่าความเข้มข้นของสนามแม่เหล็กที่ไม่ได้ปรับเทียบ
มีประโยชน์ในการจัดการกับค่าประมาณ เหล็กแข็งที่ไม่ดี โดยทั่วไป geomagneticsensor_event.values[0]
จะใกล้กับ uncalibrated_magnetometer_event.values[0] -
uncalibrated_magnetometer_event.values[3]
นั่นคือ
calibrated_x ~= uncalibrated_x - bias_estimate_x
หมายเหตุ: เซ็นเซอร์ที่ไม่ได้ปรับเทียบจะให้ผลดิบมากกว่า และอาจ มีการให้น้ำหนักพิเศษอยู่บ้าง แต่การวัดผลมีการข้ามจากการแก้ไขผ่านการแก้ไขน้อยกว่า การเทียบมาตรฐาน แอปพลิเคชันบางอย่างอาจต้องการให้ผลลัพธ์ที่ไม่มีการปรับเทียบเหล่านี้ราบรื่นและมากกว่า เชื่อถือได้ ตัวอย่างเช่น หากแอปพลิเคชันพยายามดำเนินการฟิวชันเซ็นเซอร์ของตนเอง การเริ่มใช้การปรับเทียบอาจทำให้ผลลัพธ์ผิดเพี้ยนไปได้
นอกจากสนามแม่เหล็กแล้ว เครื่องวัดค่าความเข้มข้นของสนามแม่เหล็กที่ไม่ได้ปรับยังยังมอบ การชดเชยเหล็กแข็งโดยประมาณในแต่ละแกน โค้ดต่อไปนี้แสดงวิธีรับอินสแตนซ์ของ เครื่องวัดค่าความเข้มข้นของสนามแม่เหล็กเริ่มต้นที่ไม่มีการปรับเทียบ:
Kotlin
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)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED);
ใช้พร็อกซิมิตีเซ็นเซอร์
พร็อกซิมิตีเซ็นเซอร์ช่วยให้คุณทราบว่าวัตถุอยู่ห่างจากอุปกรณ์เท่าใด ดังต่อไปนี้ โค้ดจะแสดงวิธีรับอินสแตนซ์ของพร็อกซิมิตีเซ็นเซอร์เริ่มต้น
Kotlin
private lateinit var sensorManager: SensorManager private var sensor: Sensor? = null ... sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
พร็อกซิมิตีเซ็นเซอร์มักใช้เพื่อระบุระยะห่างจากใบหน้าของบุคคล ของโทรศัพท์มือถือ (เช่น เมื่อผู้ใช้กำลังโทรออกหรือรับสาย) พบบ่อยที่สุด พร็อกซิมิตีเซ็นเซอร์จะแสดงผลระยะสัมบูรณ์เป็นหน่วยซม. แต่บางตัววัดระยะได้ใกล้เคียงและ มูลค่าที่ไกลๆ
หมายเหตุ: ในอุปกรณ์บางรุ่นจะมีพร็อกซิมิตีเซ็นเซอร์อยู่ ใต้หน้าจอ ซึ่งอาจทำให้มีจุดกะพริบปรากฏขึ้นบนหน้าจอหากเปิดใช้ขณะที่หน้าจออยู่ เปิดอยู่
รหัสต่อไปนี้แสดงวิธีใช้พร็อกซิมิตีเซ็นเซอร์
Kotlin
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) } }
Java
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); } }
หมายเหตุ: พร็อกซิมิตีเซ็นเซอร์บางตัวจะแสดงค่าไบนารีที่แสดงถึง
"ใกล้" หรือ "ไกล" ในกรณีนี้ เซ็นเซอร์มักจะรายงานค่าช่วงสูงสุดในสถานะไกล
และค่าต่ำลงในสถานะใกล้เคียง ปกติแล้วค่าไกลๆ จะเป็นค่า > 5 ซม. แต่อาจแตกต่างกันไป
ตั้งแต่เซ็นเซอร์ถึงเซ็นเซอร์ คุณสามารถกำหนดช่วงสูงสุดของเซ็นเซอร์ได้โดยใช้เมธอด getMaximumRange()