Nền tảng Android cung cấp một số cảm biến cho phép bạn theo dõi chuyển động của thiết bị.
Cấu trúc có thể có của cảm biến khác nhau tuỳ theo loại cảm biến:
- Cảm biến trọng lực, gia tốc tuyến tính, vectơ xoay, chuyển động đáng kể, bộ đếm bước và cảm biến phát hiện bước đều dựa trên phần cứng hoặc dựa trên phần mềm.
- Cảm biến gia tốc kế và con quay hồi chuyển luôn dựa trên phần cứng.
Hầu hết thiết bị chạy Android đều có gia tốc kế và nhiều thiết bị hiện có con quay hồi chuyển. Phạm vi cung cấp của các cảm biến dựa trên phần mềm có thể khác nhau vì các cảm biến này thường dựa vào một hoặc nhiều cảm biến phần cứng để lấy dữ liệu. Tuỳ thuộc vào thiết bị, các cảm biến dựa trên phần mềm này có thể lấy dữ liệu từ gia tốc kế và từ kế hoặc từ con quay hồi chuyển.
Cảm biến chuyển động rất hữu ích trong việc theo dõi chuyển động của thiết bị, chẳng hạn như độ nghiêng, độ rung, xoay hoặc xoay. Chuyển động thường phản ánh hoạt động đầu vào trực tiếp của người dùng (ví dụ: người dùng điều khiển ô tô trong trò chơi hoặc người dùng điều khiển một quả bóng trong trò chơi), nhưng cũng có thể phản ánh môi trường vật lý mà thiết bị đang ngồi (ví dụ: di chuyển cùng bạn khi bạn lái xe). Trong trường hợp đầu tiên, bạn đang theo dõi chuyển động so với hệ quy chiếu của thiết bị hoặc hệ quy chiếu của ứng dụng; trong trường hợp thứ hai, bạn đang theo dõi chuyển động so với hệ quy chiếu của thế giới. Bản thân cảm biến chuyển động thường không được dùng để giám sát vị trí thiết bị, nhưng có thể dùng với các cảm biến khác, chẳng hạn như cảm biến trường địa từ, để xác định vị trí của thiết bị so với hệ quy chiếu của thế giới (xem Cảm biến vị trí để biết thêm thông tin).
Tất cả cảm biến chuyển động đều trả về các mảng giá trị cảm biến đa chiều cho mỗi SensorEvent. Ví dụ: trong một sự kiện cảm biến, gia tốc kế trả về dữ liệu lực tăng tốc cho 3 trục toạ độ và con quay hồi chuyển trả về dữ liệu xoay cho 3 trục toạ độ. Các giá trị dữ liệu này được trả về trong một mảng float (values) cùng với các tham số SensorEvent khác. Bảng 1 tóm tắt các cảm biến chuyển động có sẵn trên nền tảng Android.
Bảng 1. Cảm biến chuyển động được hỗ trợ trên nền tảng Android.
| Cảm biến | Dữ liệu sự kiện của cảm biến | Nội dung mô tả | Đơn vị đo |
|---|---|---|---|
TYPE_ACCELEROMETER |
SensorEvent.values[0] |
Lực tăng tốc dọc theo trục x (bao gồm cả trọng lực). | m/giây2 |
SensorEvent.values[1] |
Lực tăng tốc dọc theo trục y (bao gồm cả trọng lực). | ||
SensorEvent.values[2] |
Lực tăng tốc dọc theo trục z (bao gồm cả trọng lực). | ||
TYPE_ACCELEROMETER_UNCALIBRATED |
SensorEvent.values[0] |
Gia tốc đo được dọc theo trục X mà không có bù chênh lệch. | m/giây2 |
SensorEvent.values[1] |
Gia tốc đo được dọc theo trục Y mà không có bù chênh lệch. | ||
SensorEvent.values[2] |
Gia tốc đo được dọc theo trục Z mà không có bù chênh lệch. | ||
SensorEvent.values[3] |
Gia tốc đo được dọc theo trục X với bù sai lệch ước tính. | ||
SensorEvent.values[4] |
Gia tốc đo được dọc theo trục Y với bù sai lệch ước tính. | ||
SensorEvent.values[5] |
Gia tốc đo được dọc theo trục Z với bù sai lệch ước tính. | ||
TYPE_GRAVITY |
SensorEvent.values[0] |
Trọng lực dọc theo trục x. | m/giây2 |
SensorEvent.values[1] |
Trọng lực dọc theo trục y. | ||
SensorEvent.values[2] |
Trọng lực dọc theo trục z. | ||
TYPE_GYROSCOPE |
SensorEvent.values[0] |
Tốc độ quay xung quanh trục x. | Rad/giây |
SensorEvent.values[1] |
Tốc độ quay xung quanh trục y. | ||
SensorEvent.values[2] |
Tốc độ quay xung quanh trục z. | ||
TYPE_GYROSCOPE_UNCALIBRATED |
SensorEvent.values[0] |
Tốc độ quay (không bù độ trôi) xung quanh trục x. | Rad/giây |
SensorEvent.values[1] |
Tốc độ quay (không bù độ trôi) xung quanh trục y. | ||
SensorEvent.values[2] |
Tốc độ quay (không bù độ trôi) xung quanh trục z. | ||
SensorEvent.values[3] |
Độ trôi ước tính xung quanh trục x. | ||
SensorEvent.values[4] |
Độ trôi ước tính xung quanh trục y. | ||
SensorEvent.values[5] |
Độ trôi ước tính xung quanh trục z. | ||
TYPE_LINEAR_ACCELERATION |
SensorEvent.values[0] |
Lực tăng tốc dọc theo trục x (không bao gồm trọng lực). | m/giây2 |
SensorEvent.values[1] |
Lực gia tốc dọc theo trục y (không bao gồm trọng lực). | ||
SensorEvent.values[2] |
Lực tăng tốc dọc theo trục z (không bao gồm trọng lực). | ||
TYPE_ROTATION_VECTOR |
SensorEvent.values[0] |
Thành phần vectơ xoay dọc theo trục x (x * sin(;/2)). | Không có đơn vị |
SensorEvent.values[1] |
Thành phần vectơ xoay dọc theo trục y (y * sin(9/2)). | ||
SensorEvent.values[2] |
Thành phần vectơ xoay dọc theo trục z (z * sin(;/2)). | ||
SensorEvent.values[3] |
Thành phần vô hướng của vectơ xoay ((cos(;) / 2).1 | ||
TYPE_SIGNIFICANT_MOTION |
Không áp dụng | Không có câu trả lời thích hợp | Không áp dụng |
TYPE_STEP_COUNTER |
SensorEvent.values[0] |
Số bước mà người dùng đã thực hiện kể từ lần khởi động lại gần đây nhất trong khi cảm biến được kích hoạt. | Các bước |
TYPE_STEP_DETECTOR |
Không áp dụng | Không có câu trả lời thích hợp | Không áp dụng |
1 Thành phần vô hướng là một giá trị không bắt buộc.
Cảm biến vectơ xoay và cảm biến trọng lực là những cảm biến được dùng thường xuyên nhất để phát hiện và theo dõi chuyển động. Cảm biến vectơ xoay đặc biệt linh hoạt và có thể dùng cho nhiều tác vụ liên quan đến chuyển động, chẳng hạn như phát hiện cử chỉ, theo dõi sự thay đổi góc và theo dõi các thay đổi về hướng tương đối. Ví dụ: cảm biến vectơ xoay là lựa chọn lý tưởng nếu bạn đang phát triển trò chơi, ứng dụng thực tế tăng cường, la bàn 2 chiều hoặc 3 chiều hoặc ứng dụng ổn định máy ảnh. Trong hầu hết các trường hợp, việc sử dụng các cảm biến này là lựa chọn tốt hơn so với việc sử dụng gia tốc kế và cảm biến trường địa từ hoặc cảm biến hướng.
Cảm biến của Dự án nguồn mở Android
Dự án nguồn mở Android (AOSP) cung cấp 3 cảm biến chuyển động dựa trên phần mềm: cảm biến trọng lực, cảm biến gia tốc tuyến tính và cảm biến vectơ xoay. Các cảm biến này đã được cập nhật trong Android 4.0 và hiện sử dụng con quay hồi chuyển của thiết bị (cùng với các cảm biến khác) để cải thiện độ ổn định và hiệu suất. Nếu muốn dùng thử các cảm biến này, bạn có thể xác định chúng bằng cách sử dụng phương thức getVendor() và phương thức getVersion() (nhà cung cấp là Google LLC; số phiên bản là 3). Bạn cần xác định các cảm biến này theo nhà cung cấp và số phiên bản vì hệ thống Android coi 3 cảm biến này là cảm biến phụ. Ví dụ: nếu nhà sản xuất thiết bị cung cấp cảm biến trọng lực riêng, thì cảm biến trọng lực AOSP sẽ xuất hiện dưới dạng cảm biến trọng lực phụ. Cả 3 cảm biến này đều dựa vào con quay hồi chuyển: nếu thiết bị không có con quay hồi chuyển, thì các cảm biến này sẽ không xuất hiện và không sử dụng được.
Sử dụng cảm biến trọng lực
Cảm biến trọng lực cung cấp một vectơ ba chiều cho biết hướng và độ lớn của trọng lực. Thông thường, cảm biến này dùng để xác định hướng tương đối của thiết bị trong không gian. Đoạn mã sau đây cho bạn biết cách tải một thực thể của cảm biến trọng lực mặc định:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY);
Các đơn vị này giống với đơn vị mà cảm biến gia tốc (m/s2) sử dụng và hệ toạ độ giống với hệ thống mà cảm biến gia tốc sử dụng.
Lưu ý: Khi một thiết bị ở trạng thái nghỉ, đầu ra của cảm biến trọng lực phải giống với đầu ra của gia tốc kế.
Sử dụng gia tốc kế tuyến tính
Cảm biến gia tốc tuyến tính cung cấp cho bạn một vectơ ba chiều biểu thị gia tốc dọc theo từng trục của thiết bị, không bao gồm trọng lực. Bạn có thể dùng giá trị này để thực hiện việc phát hiện cử chỉ. Giá trị này cũng có thể đóng vai trò là dữ liệu đầu vào cho hệ thống điều hướng quán tính, hệ thống này sử dụng phương thức tính toán cụ thể. Đoạn mã sau đây cho bạn biết cách tải một thực thể của cảm biến gia tốc tuyến tính mặc định:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);
Về mặt lý thuyết, cảm biến này cung cấp cho bạn dữ liệu tăng tốc theo mối quan hệ sau:
linear acceleration = acceleration - acceleration due to gravity
Bạn thường sử dụng cảm biến này khi muốn lấy dữ liệu gia tốc mà không chịu ảnh hưởng của trọng lực. Ví dụ: bạn có thể sử dụng cảm biến này để xem tốc độ của ô tô. Cảm biến tăng tốc tuyến tính luôn có một giá trị bù trừ (offset) mà bạn cần xoá. Cách đơn giản nhất để thực hiện việc này là tạo một bước hiệu chỉnh trong ứng dụng của bạn. Trong quá trình hiệu chỉnh, bạn có thể yêu cầu người dùng đặt thiết bị trên bàn, sau đó đọc độ lệch của cả 3 trục. Sau đó, bạn có thể trừ đi mức chênh lệch đó từ các chỉ số trực tiếp của cảm biến gia tốc để có được tốc độ tăng tốc tuyến tính thực tế.
Hệ thống toạ độ của cảm biến giống với hệ thống mà cảm biến gia tốc sử dụng, cũng như đơn vị đo (m/s2).
Sử dụng cảm biến vectơ xoay
Vectơ xoay biểu thị hướng của thiết bị dưới dạng sự kết hợp giữa một góc và một trục, trong đó thiết bị đã xoay qua một góc vai xung quanh một trục (x, y hoặc z). Mã sau đây cho bạn biết cách tải một thực thể của cảm biến vectơ xoay mặc định:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
Ba phần tử của vectơ xoay được biểu diễn như sau:
Trong đó độ lớn của vectơ xoay bằng sin(9/2) và hướng của vectơ xoay bằng hướng của trục xoay.
Hình 1. Hệ toạ độ mà cảm biến vectơ xoay sử dụng.
Ba phần tử của vectơ xoay bằng ba thành phần cuối của một quaternion đơn vị (cos(góc/2 ), x*sin( ) / 2 , y*sin(tại/2 ), z*sin(tại/2 ) ). Các phần tử của vectơ xoay là không đơn vị. Các trục x, y và z được xác định theo cách tương tự như cảm biến gia tốc. Hệ toạ độ tham chiếu được định nghĩa là cơ sở trực tiếp hoặc trực giao (xem hình 1). Hệ toạ độ này có các đặc điểm sau:
- X được định nghĩa là tích vectơ Y x Z. Nó tiếp tuyến với mặt đất tại vị trí hiện tại của thiết bị và điểm gần về phía Đông.
- Y là tiếp tuyến với mặt đất tại vị trí hiện tại của thiết bị và chỉ về phía Bắc Cực địa từ.
- Z trỏ tới bầu trời và vuông góc với mặt phẳng mặt đất.
Để xem ứng dụng mẫu cho biết cách sử dụng cảm biến vectơ xoay, hãy xem RotationVectordemo.java.
Sử dụng cảm biến chuyển động quan trọng
Cảm biến chuyển động quan trọng sẽ kích hoạt một sự kiện mỗi khi phát hiện thấy chuyển động quan trọng, sau đó cảm biến này sẽ tự tắt. Chuyển động đáng kể là chuyển động có thể dẫn đến thay đổi về vị trí của người dùng; ví dụ: đi bộ, đi xe đạp hoặc ngồi trong ô tô đang chuyển động. Đoạn mã sau đây cho bạn biết cách tải một thực thể của cảm biến chuyển động quan trọng mặc định và cách đăng ký một trình nghe sự kiện:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val mSensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION)
val triggerEventListener = object : TriggerEventListener() {
override fun onTrigger(event: TriggerEvent?) {
// Do work
}
}
mSensor?.also { sensor ->
sensorManager.requestTriggerSensor(triggerEventListener, sensor)
}
Java
private SensorManager sensorManager;
private Sensor sensor;
private TriggerEventListener triggerEventListener;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION);
triggerEventListener = new TriggerEventListener() {
@Override
public void onTrigger(TriggerEvent event) {
// Do work
}
};
sensorManager.requestTriggerSensor(triggerEventListener, mSensor);
Để biết thêm thông tin, hãy xem TriggerEventListener.
Sử dụng cảm biến bộ đếm số bước
Cảm biến bộ đếm bước cho biết số bước mà người dùng đã thực hiện kể từ lần khởi động lại gần đây nhất trong khi cảm biến được kích hoạt. Bộ đếm bước có độ trễ cao hơn (tối đa 10 giây) nhưng độ chính xác cao hơn so với cảm biến trình phát hiện bước.
Lưu ý: Bạn phải khai báo quyền ACTIVITY_RECOGNITION để ứng dụng dùng cảm biến này trên các thiết bị chạy Android 10 (API cấp 29) trở lên.
Đoạn mã sau đây cho bạn biết cách lấy một thực thể của cảm biến bộ đếm bước mặc định:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);
Để duy trì pin trên các thiết bị chạy ứng dụng, bạn nên sử dụng lớp JobScheduler để truy xuất giá trị hiện tại từ cảm biến bộ đếm bước tại một khoảng thời gian cụ thể. Mặc dù mỗi loại ứng dụng yêu cầu khoảng thời gian đọc cảm biến khác nhau, nhưng bạn nên thực hiện khoảng thời gian này càng lâu càng tốt, trừ phi ứng dụng của bạn yêu cầu dữ liệu theo thời gian thực từ cảm biến.
Sử dụng cảm biến phát hiện số bước
Cảm biến trình phát hiện số bước sẽ kích hoạt một sự kiện mỗi khi người dùng đi một bước. Độ trễ dự kiến sẽ dưới 2 giây.
Lưu ý: Bạn phải khai báo quyền ACTIVITY_RECOGNITION để ứng dụng dùng cảm biến này trên các thiết bị chạy Android 10 (API cấp 29) trở lên.
Đoạn mã sau đây cho bạn biết cách lấy một thực thể của cảm biến phát hiện bước mặc định:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);
Làm việc với dữ liệu thô
Các cảm biến sau đây cung cấp cho ứng dụng của bạn dữ liệu thô về các lực tuyến tính và lực xoay đang được áp dụng cho thiết bị. Để sử dụng hiệu quả giá trị từ những cảm biến này, bạn cần lọc ra các yếu tố của môi trường, chẳng hạn như trọng lực. Có thể bạn cũng cần áp dụng thuật toán làm mượt cho xu hướng của các giá trị để giảm độ nhiễu.
Sử dụng gia tốc kế
Cảm biến gia tốc đo lường gia tốc áp dụng cho thiết bị, bao gồm cả lực hấp dẫn. Đoạn mã sau đây cho bạn biết cách lấy một thực thể của cảm biến gia tốc mặc định:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
Lưu ý: Nếu ứng dụng của bạn nhắm đến Android 12 (API cấp 31) trở lên, thì cảm biến này sẽ bị giới hạn tốc độ.
Về mặt lý thuyết, cảm biến gia tốc sẽ xác định gia tốc áp dụng cho một thiết bị (Ad) bằng cách đo lường các lực tác dụng lên chính cảm biến đó (Fs) thông qua mối quan hệ sau:
Tuy nhiên, lực hấp dẫn luôn ảnh hưởng đến gia tốc đo được theo mối quan hệ sau:
Vì lý do này, khi thiết bị đang ở trên bàn (và không tăng tốc), gia tốc kế sẽ đọc cường độ là g = 9,81 m/s2. Tương tự, khi thiết bị rơi tự do và do đó nhanh chóng tăng tốc về phía mặt đất với vận tốc 9,81 m/s2, gia tốc kế của thiết bị cho biết cường độ là g = 0 m/s2. Do đó, để đo gia tốc thực của thiết bị, đóng góp của lực hấp dẫn phải được xoá khỏi dữ liệu gia tốc kế. Điều này có thể đạt được bằng cách áp dụng bộ lọc thông cao. Ngược lại, bộ lọc thông thấp có thể được dùng để tách biệt lực hấp dẫn. Ví dụ sau cho thấy cách bạn có thể thực hiện việc này:
Kotlin
override fun onSensorChanged(event: SensorEvent) {
// In this example, alpha is calculated as t / (t + dT),
// where t is the low-pass filter's time-constant and
// dT is the event delivery rate.
val alpha: Float = 0.8f
// Isolate the force of gravity with the low-pass filter.
gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0]
gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1]
gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2]
// Remove the gravity contribution with the high-pass filter.
linear_acceleration[0] = event.values[0] - gravity[0]
linear_acceleration[1] = event.values[1] - gravity[1]
linear_acceleration[2] = event.values[2] - gravity[2]
}
Java
public void onSensorChanged(SensorEvent event){
// In this example, alpha is calculated as t / (t + dT),
// where t is the low-pass filter's time-constant and
// dT is the event delivery rate.
final float alpha = 0.8;
// Isolate the force of gravity with the low-pass filter.
gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0];
gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1];
gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2];
// Remove the gravity contribution with the high-pass filter.
linear_acceleration[0] = event.values[0] - gravity[0];
linear_acceleration[1] = event.values[1] - gravity[1];
linear_acceleration[2] = event.values[2] - gravity[2];
}
Lưu ý: Bạn có thể sử dụng nhiều kỹ thuật để lọc dữ liệu cảm biến. Mã mẫu ở trên sử dụng hằng số bộ lọc đơn giản (alpha) để tạo bộ lọc thông thấp. Hằng số bộ lọc này lấy từ hằng số thời gian (t). Đây là hằng số thời gian đại diện cho độ trễ mà bộ lọc thêm vào các sự kiện cảm biến và tốc độ phân phối sự kiện của cảm biến (dt). Mã mẫu sử dụng giá trị alpha là 0,8 cho mục đích minh hoạ. Nếu sử dụng phương thức lọc này, bạn có thể cần chọn một giá trị alpha khác.
Gia tốc kế sử dụng hệ thống toạ độ của cảm biến tiêu chuẩn. Trong thực tế, điều này có nghĩa là các điều kiện sau đây áp dụng khi một thiết bị được đặt trên bàn theo hướng tự nhiên:
- Nếu bạn đẩy thiết bị sang bên trái (để thiết bị di chuyển sang bên phải), thì giá trị gia tốc x là giá trị dương.
- Nếu bạn đẩy thiết bị xuống dưới (để thiết bị di chuyển ra xa bạn), thì giá trị gia tốc y là số dương.
- Nếu bạn đẩy thiết bị về phía bầu trời với gia tốc A m/s2, thì giá trị gia tốc z sẽ bằng A + 9,81, tương ứng với gia tốc của thiết bị (+A m/s2) trừ đi lực hấp dẫn (-9,81 m/s2).
- Thiết bị đứng yên sẽ có giá trị gia tốc +9,81, tương ứng với gia tốc của thiết bị (0 m/s2 trừ đi lực hấp dẫn là -9,81 m/s2).
Nhìn chung, gia tốc kế là một cảm biến thích hợp để sử dụng nếu bạn đang theo dõi chuyển động của thiết bị. Hầu hết điện thoại di động và máy tính bảng chạy Android đều có gia tốc kế và tiêu thụ năng lượng ít hơn khoảng 10 lần so với các cảm biến chuyển động khác. Một nhược điểm là bạn có thể phải triển khai các bộ lọc thông thấp và thông cao để loại bỏ lực hấp dẫn và giảm độ nhiễu.
Sử dụng con quay hồi chuyển
Con quay hồi chuyển đo tốc độ quay theo Rad/s xung quanh trục x, y và z của thiết bị. Đoạn mã sau đây cho bạn biết cách tải một thực thể của con quay hồi chuyển mặc định:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
Lưu ý: Nếu ứng dụng của bạn nhắm đến Android 12 (API cấp 31) trở lên, thì cảm biến này sẽ bị giới hạn tốc độ.
Hệ thống toạ độ của cảm biến giống với hệ thống dùng cho cảm biến gia tốc. Xoay có giá trị dương theo hướng ngược chiều kim đồng hồ; tức là đối tượng tiếp nhận dữ liệu nhìn từ vị trí dương nào đó trên trục x, y hoặc z tại một thiết bị được đặt trên gốc sẽ báo cáo hướng xoay dương nếu thiết bị có vẻ như đang xoay ngược chiều kim đồng hồ. Đây là định nghĩa toán học chuẩn của chế độ xoay dương và không giống với định nghĩa cuộn mà cảm biến hướng sử dụng.
Thông thường, đầu ra của con quay hồi chuyển được tích hợp theo thời gian để tính toán độ xoay, mô tả sự thay đổi các góc theo bước thời gian. Ví dụ:
Kotlin
// Create a constant to convert nanoseconds to seconds.
private val NS2S = 1.0f / 1000000000.0f
private val deltaRotationVector = FloatArray(4) { 0f }
private var timestamp: Float = 0f
override fun onSensorChanged(event: SensorEvent?) {
// This timestep's delta rotation to be multiplied by the current rotation
// after computing it from the gyro sample data.
if (timestamp != 0f && event != null) {
val dT = (event.timestamp - timestamp) * NS2S
// Axis of the rotation sample, not normalized yet.
var axisX: Float = event.values[0]
var axisY: Float = event.values[1]
var axisZ: Float = event.values[2]
// Calculate the angular speed of the sample
val omegaMagnitude: Float = sqrt(axisX * axisX + axisY * axisY + axisZ * axisZ)
// Normalize the rotation vector if it's big enough to get the axis
// (that is, EPSILON should represent your maximum allowable margin of error)
if (omegaMagnitude > EPSILON) {
axisX /= omegaMagnitude
axisY /= omegaMagnitude
axisZ /= omegaMagnitude
}
// Integrate around this axis with the angular speed by the timestep
// in order to get a delta rotation from this sample over the timestep
// We will convert this axis-angle representation of the delta rotation
// into a quaternion before turning it into the rotation matrix.
val thetaOverTwo: Float = omegaMagnitude * dT / 2.0f
val sinThetaOverTwo: Float = sin(thetaOverTwo)
val cosThetaOverTwo: Float = cos(thetaOverTwo)
deltaRotationVector[0] = sinThetaOverTwo * axisX
deltaRotationVector[1] = sinThetaOverTwo * axisY
deltaRotationVector[2] = sinThetaOverTwo * axisZ
deltaRotationVector[3] = cosThetaOverTwo
}
timestamp = event?.timestamp?.toFloat() ?: 0f
val deltaRotationMatrix = FloatArray(9) { 0f }
SensorManager.getRotationMatrixFromVector(deltaRotationMatrix, deltaRotationVector);
// User code should concatenate the delta rotation we computed with the current rotation
// in order to get the updated rotation.
// rotationCurrent = rotationCurrent * deltaRotationMatrix;
}
Java
// Create a constant to convert nanoseconds to seconds.
private static final float NS2S = 1.0f / 1000000000.0f;
private final float[] deltaRotationVector = new float[4]();
private float timestamp;
public void onSensorChanged(SensorEvent event) {
// This timestep's delta rotation to be multiplied by the current rotation
// after computing it from the gyro sample data.
if (timestamp != 0) {
final float dT = (event.timestamp - timestamp) * NS2S;
// Axis of the rotation sample, not normalized yet.
float axisX = event.values[0];
float axisY = event.values[1];
float axisZ = event.values[2];
// Calculate the angular speed of the sample
float omegaMagnitude = sqrt(axisX*axisX + axisY*axisY + axisZ*axisZ);
// Normalize the rotation vector if it's big enough to get the axis
// (that is, EPSILON should represent your maximum allowable margin of error)
if (omegaMagnitude > EPSILON) {
axisX /= omegaMagnitude;
axisY /= omegaMagnitude;
axisZ /= omegaMagnitude;
}
// Integrate around this axis with the angular speed by the timestep
// in order to get a delta rotation from this sample over the timestep
// We will convert this axis-angle representation of the delta rotation
// into a quaternion before turning it into the rotation matrix.
float thetaOverTwo = omegaMagnitude * dT / 2.0f;
float sinThetaOverTwo = sin(thetaOverTwo);
float cosThetaOverTwo = cos(thetaOverTwo);
deltaRotationVector[0] = sinThetaOverTwo * axisX;
deltaRotationVector[1] = sinThetaOverTwo * axisY;
deltaRotationVector[2] = sinThetaOverTwo * axisZ;
deltaRotationVector[3] = cosThetaOverTwo;
}
timestamp = event.timestamp;
float[] deltaRotationMatrix = new float[9];
SensorManager.getRotationMatrixFromVector(deltaRotationMatrix, deltaRotationVector);
// User code should concatenate the delta rotation we computed with the current rotation
// in order to get the updated rotation.
// rotationCurrent = rotationCurrent * deltaRotationMatrix;
}
Con quay hồi chuyển chuẩn cung cấp dữ liệu xoay thô mà không có bộ lọc hoặc chỉnh sửa độ nhiễu và độ lệch (độ lệch). Trong thực tế, độ nhiễu và độ trôi của con quay hồi chuyển sẽ tạo ra các lỗi cần phải bù trừ. Bạn thường xác định độ lệch (độ lệch) và độ nhiễu bằng cách theo dõi các cảm biến khác, chẳng hạn như cảm biến trọng lực hoặc gia tốc kế.
Sử dụng con quay hồi chuyển chưa được hiệu chỉnh
Con quay hồi chuyển chưa được hiệu chỉnh tương tự như con quay hồi chuyển, ngoại trừ việc không áp dụng bù trừ con quay hồi chuyển cho tốc độ xoay. Chế độ hiệu chỉnh và bù nhiệt độ tại nhà máy vẫn được áp dụng cho tốc độ xoay. Con quay hồi chuyển chưa được hiệu chỉnh rất hữu ích cho việc xử lý hậu kỳ và hợp nhất dữ liệu hướng. Nhìn chung, gyroscope_event.values[0] sẽ gần với uncalibrated_gyroscope_event.values[0] - uncalibrated_gyroscope_event.values[3].
Tức là
calibrated_x ~= uncalibrated_x - bias_estimate_x
Lưu ý: Các cảm biến chưa được hiệu chỉnh cung cấp nhiều kết quả thô hơn và có thể có một số độ chệch. Tuy nhiên, kết quả đo lường có ít bước nhảy hơn so với các giá trị hiệu chỉnh được áp dụng trong quá trình hiệu chuẩn. Một số ứng dụng có thể muốn các kết quả chưa được hiệu chỉnh này mượt mà và đáng tin cậy hơn. Ví dụ: nếu một ứng dụng đang cố gắng tiến hành hợp nhất cảm biến của riêng mình, thì việc đưa vào các hiệu chuẩn có thể thực sự làm sai lệch kết quả.
Ngoài tốc độ quay, con quay hồi chuyển chưa được hiệu chỉnh còn cung cấp độ trôi ước tính xung quanh mỗi trục. Mã sau đây cho bạn biết cách lấy một bản sao của con quay hồi chuyển mặc định chưa được hiệu chỉnh:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED);
Mã mẫu khác
Mẫu BatchStepSensor minh hoạ thêm về cách sử dụng các API được trình bày trên trang này.