求解释?手机的方向感应器，加速感应器，具体解释？有什么用处？
本回答由提问者推荐
var sogou_ad_id=731547;
var sogou_ad_height=160;
var sogou_ad_width=690;In my app i wanted to show device direction such as north, south, east, west. For that i am using accelerometer and magnetic sensor and tried with following code.
public class MainActivity extends Activity implements SensorEventListener
public static float swR
public static float swP
public static float swA
public static SensorManager mSensorM
public static S
public static S
public static float[] mAccelerometer =
public static float[] mGeomagnetic =
public void onAccuracyChanged(Sensor sensor, int accuracy) {
public void onSensorChanged(SensorEvent event)
// onSensorChanged gets called for each sensor so we have to remember the values
if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER)
mAccelerometer = event.
if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD)
mGeomagnetic = event.
if (mAccelerometer != null && mGeomagnetic != null)
float R[] = new float[9];
float I[] = new float[9];
boolean success = SensorManager.getRotationMatrix(R, I, mAccelerometer, mGeomagnetic);
if (success)
float orientation[] = new float[3];
SensorManager.getOrientation(R, orientation);
// at this point, orientation contains the azimuth(direction), pitch and roll values.
double azimuth = 180 * orientation[0] / Math.PI;
//double pitch = 180 * orientation[1] / Math.PI;
//double roll = 180 * orientation[2] / Math.PI;
Toast.makeText(getApplicationContext(), "azimuth: "+azimuth, Toast.LENGTH_SHORT).show();
//Toast.makeText(getApplicationContext(), "pitch: "+pitch, Toast.LENGTH_SHORT).show();
//Toast.makeText(getApplicationContext(), "roll: "+roll, Toast.LENGTH_SHORT).show();
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSensorManager = (SensorManager)getSystemService(SENSOR_SERVICE);
accelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
magnetometer = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
protected void onResume() {
super.onResume();
mSensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_GAME);
mSensorManager.registerListener(this, magnetometer, SensorManager.SENSOR_DELAY_GAME);
protected void onPause() {
super.onPause();
mSensorManager.unregisterListener(this, accelerometer);
mSensorManager.unregisterListener(this, magnetometer);
I read some artical and come to know that azimuth value is use for getting direction. But it not shows proper value i.e it always shows value between 103 to 140 in any direction. I am using samsung galaxy s for test purpose. where i goes wrong.
Any help will be appreciated...thank you
解决方案 EDIT:
I'm going to keep this answer up because there are no other answers here, but my gut feeling looking at this code again is it probably doesn't work well.
Use at your own risk, and if anyone ever gives a decent answer I'll delete this
Here's a compass sensor I wrote for my own use.
It works, somewhat.
In reality it needs better filtering-
the results from the sensor are very noisy, I built a filter on top of it to slow the updates and it improved things, but it needs a much better filter if it was to be used in production
package com.gabesechan.android.reusable.
import java.lang.ref.WeakR
import java.util.HashS
import android.content.C
import android.hardware.S
import android.hardware.SensorE
import android.hardware.SensorEventL
import android.hardware.SensorM
import android.os.H
import android.os.M
public class CompassSensor {
int lastDirection = -1;
boolean firstReading =
HashSet&CompassListener& listeners = new HashSet&CompassListener&();
static CompassSensor mI
public static CompassSensor getInstance(Context ctx){
if(mInstance == null){
mInstance = new CompassSensor(ctx);
private CompassSensor(Context ctx){
sm = (SensorManager) ctx.getSystemService(Context.SENSOR_SERVICE);
onResume();
public void onResume(){
sm.registerListener(sensorListener, sm.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL);
sm.registerListener(sensorListener, sm.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD), SensorManager.SENSOR_DELAY_UI);
firstReading =
//Restart the timer only if we have listeners
if(listeners.size()&0){
handler.sendMessageDelayed(Message.obtain(handler, 1),1000);
public void onPause(){
sm.unregisterListener(sensorListener);
handler.removeMessages(1);
private final SensorEventListener sensorListener = new SensorEventListener(){
float accelerometerValues[] =
float geomagneticMatrix[] =
public void onSensorChanged(SensorEvent event) {
if (event.accuracy == SensorManager.SENSOR_STATUS_UNRELIABLE)
switch (event.sensor.getType()) {
case Sensor.TYPE_ACCELEROMETER:
accelerometerValues = event.values.clone();
case Sensor.TYPE_MAGNETIC_FIELD:
geomagneticMatrix = event.values.clone();
if (geomagneticMatrix != null && accelerometerValues != null && event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
float[] R = new float[16];
float[] I = new float[16];
float[] outR = new float[16];
//Get the rotation matrix, then remap it from camera surface to world coordinates
SensorManager.getRotationMatrix(R, I, accelerometerValues, geomagneticMatrix);
SensorManager.remapCoordinateSystem(R, SensorManager.AXIS_X, SensorManager.AXIS_Z, outR);
float values[] = new float[4];
SensorManager.getOrientation(outR,values);
int direction = normalizeDegrees(filterChange((int)Math.toDegrees(values[0])));
int pitch = normalizeDegrees(Math.toDegrees(values[1]));
int roll = normalizeDegrees(Math.toDegrees(values[2]));
if((int)direction != (int)lastDirection){
lastDirection = (int)
lastPitch = (int)
lastRoll = (int)
public void onAccuracyChanged(Sensor sensor, int accuracy) {
//Normalize a degree from 0 to 360 instead of -180 to 180
private int normalizeDegrees(double rads){
return (int)((rads+360)%360);
//We want to ignore large bumps in individual readings.
So we're going to cap the number of degrees we can change per report
private static final int MAX_CHANGE = 3;
private int filterChange(int newDir){
newDir = normalizeDegrees(newDir);
//On the first reading, assume it's right.
Otherwise NW readings take forever to ramp up
if(firstReading){
firstReading =
return newD
//Figure out how many degrees to move
int delta = newDir - lastD
int normalizedDelta = normalizeDegrees(delta);
int change = Math.min(Math.abs(delta),MAX_CHANGE);
//We always want to move in the direction of lower distance.
So if newDir is lower and delta is less than half a circle, lower lastDir
// Same if newDir is higher but the delta is more than half a circle (you'd be faster in the other direction going lower).
if( normalizedDelta & 180 ){
change = -
return lastDirection+
public void addListener(CompassListener listener){
if(listeners.size() == 0){
//Start the timer on first listener
handler.sendMessageDelayed(Message.obtain(handler, 1),1000);
listeners.add(listener);
public void removeListener(CompassListener listener){
listeners.remove(listener);
if(listeners.size() == 0){
handler.removeMessages(1);
public int getLastDirection(){
return lastD
public int getLastPitch(){
return lastP
public int getLastRoll(){
return lastP
private void callListeners(){
for(CompassListener listener: listeners){
listener.onDirectionChanged(lastDirection, lastPitch, lastRoll);
//This handler is run every 1s, and updates the listeners
//Static class because otherwise we leak, Eclipse told me so
static class IncomingHandler extends Handler {
private final WeakReference&CompassSensor& compassS
IncomingHandler(CompassSensor sensor) {
compassSensor = new WeakReference&CompassSensor&(sensor);
public void handleMessage(Message msg)
CompassSensor sensor = compassSensor.get();
if (sensor != null) {
sensor.callListeners();
sendMessageDelayed(Message.obtain(this, 1), 1000);
IncomingHandler handler = new IncomingHandler(this);
public interface CompassListener {
void onDirectionChanged(int direction, int pitch, int roll);
本文地址： &
在我的应用我想显示设备的方向，如北，南，东，西。对于我使用加速计和磁传感器，并与下面code尝试。 公共类MainActivity扩展活动实现SensorEventListener{公共静态浮动swR公共静态浮动swP公共静态浮动swA公共静态的SensorManager mSensorM公共静态Sensor重力感应;公共静态传感器磁强计;公共静态浮动[] mAccelerometer = NULL;公共静态浮动[] mGeomagnetic = NULL;公共无效onAccuracyChanged（传感器传感器，精度INT）{}@覆盖公共无效onSensorChanged（SensorEvent事件）{
// onSensorChanged被调用为每个传感器，所以我们要记住的值
如果（event.sensor.getType（）== Sensor.TYPE_ACCELEROMETER）
mAccelerometer = event.
如果（event.sensor.getType（）== Sensor.TYPE_MAGNETIC_FIELD）
mGeomagnetic = event.
如果（mAccelerometer = NULL＆放大器;！＆安培;！mGeomagnetic = NULL）
[R [] =新的浮动[9];
浮动我[] =新的浮动[9];
布尔成功= SensorManager.getRotationMatrix（R，I，mAccelerometer，mGeomagnetic）;
如果（成功）
浮动方向[] =新的浮动[3];
SensorManager.getOrientation（R，取向）;
//在这一点上，取向包含方位（方向），俯仰和滚转值。
双方位角= 180 *取向[0] / Math.PI;
//双节距= 180 *方向[1] / Math.PI;
//双辊= 180 *方向[2] / Math.PI;
Toast.makeText（getApplicationContext（），“方位角：”+方位，Toast.LENGTH_SHORT）.show（）;
//Toast.makeText（getApplicationContext（），“音调：”+螺距，Toast.LENGTH_SHORT）.show（）;
//Toast.makeText（getApplicationContext（），“卷：”+辊，Toast.LENGTH_SHORT）.show（）;
}}@覆盖保护无效的onCreate（捆绑savedInstanceState）{
super.onCreate（savedInstanceState）;
mSensorManager =（的SensorManager）getSystemService（SENSOR_SERVICE）;
加速度= mSensorManager.getDefaultSensor（Sensor.TYPE_ACCELEROMETER）;
磁力= mSensorManager.getDefaultSensor（Sensor.TYPE_MAGNETIC_FIELD）;}@覆盖保护无效onResume（）{
super.onResume（）;
mSensorManager.registerListener（这一点，加速度计，SensorManager.SENSOR_DELAY_GAME）;
mSensorManager.registerListener（这一点，磁强计，SensorManager.SENSOR_DELAY_GAME）;}@覆盖保护无效的onPause（）{
super.onPause（）;
mSensorManager.unregisterListener（这一点，加速度计）;
mSensorManager.unregisterListener（这一点，磁力计）;}} 我看了一些ARTICAL和来知道方位值是用于获得方向。但它没有显示应有的价值即它总是显示在任意方向的103至140的值。我使用的三星Galaxy S测试的目的。其中i出错。任何帮助将AP preciated ...谢谢解决方案 编辑：我要去，因为没有其他的答案在这里，但我的直觉在这个code再次寻找它是保持这个答案了可能不能很好地工作。使用您自己的风险，如果有谁给一个像样的答案，我会删除此下面是我写我自己用的指南针传感器。它的工作原理，有点。在现实中，它需要更好的filtering-来自传感器的结果非常嘈杂，我建立在它之上，以减缓更新一个过滤器，它改善了的东西，但它需要一个更好的过滤器，如果它是在生产中使用 包com.gabesechan.android.reusable.进口java.lang.ref.WeakR进口java.util.HashSet中;进口android.content.C进口android.hardware.S进口android.hardware.SensorE进口android.hardware.SensorEventL进口android.hardware.SensorM进口android.os.H进口android.os.M公共类CompassSensor {SM的SensorMINT lastDirection = -1;INT lastPINT lastR布尔firstReading = TRUE;HashSet的＆LT; CompassListener＆GT;听众=新的HashSet＆LT; CompassListener＆GT;（）;静态CompassSensor mI公共静态CompassSensor的getInstance（上下文CTX）{
如果（mInstance == NULL）{
mInstance =新CompassSensor（CTX）;
返回mI}私人CompassSensor（上下文CTX）{
SM =（的SensorManager）ctx.getSystemService（Context.SENSOR_SERVICE）;
onResume（）;}公共无效onResume（）{
sm.registerListener（sensorListener，sm.getDefaultSensor（Sensor.TYPE_ACCELEROMETER），SensorManager.SENSOR_DELAY_NORMAL）;
sm.registerListener（sensorListener，sm.getDefaultSensor（Sensor.TYPE_MAGNETIC_FIELD），SensorManager.SENSOR_DELAY_UI）;
firstReading = TRUE;
//重新启动只有当我们有听众计时器
如果（listeners.size（）大于0）{
handler.sendMessageDelayed（Message.obtain（处理器，1），1000）;
}}公共无效的onPause（）{
sm.unregisterListener（sensorListener）;
handler.removeMessages（1）;}私人最终SensorEventListener sensorListener =新SensorEventListener（）{
浮accelerometerValues [] = NULL;
浮geomagneticMatrix [] = NULL;
公共无效onSensorChanged（SensorEvent事件）{
如果（event.accuracy == SensorManager.SENSOR_STATUS_UNRELIABLE）
开关（event.sensor.getType（））{
案例Sensor.TYPE_ACCELEROMETER：
accelerometerValues = event.values.clone（）;
案例Sensor.TYPE_MAGNETIC_FIELD：
geomagneticMatrix = event.values.clone（）;
如果（geomagneticMatrix = NULL＆放大器;！＆安培; accelerometerValues = NULL＆放大器;！＆安培; event.sensor.getType（）== Sensor.TYPE_MAGNETIC_FIELD）{
浮动[] R =新的浮动[16];
浮动[] I =新的浮动[16];
浮动[] = OUTR新的浮动[16];
//获取旋转矩阵，然后从相机表面为世界坐标重新映射
SensorManager.getRotationMatrix（R，I，accelerometerValues，geomagneticMatrix）;
SensorManager.remapCoordinateSystem（R，SensorManager.AXIS_X，SensorManager.AXIS_Z，OUTR）;
浮点值[] =新的浮动[4];
SensorManager.getOrientation（OUTR，价值观）;
INT方向= normalizeDegrees（filterChange（（int）的Math.toDegrees（值[0]）））;
INT节距= normalizeDegrees（Math.toDegrees（值[1]））;
INT辊= normalizeDegrees（Math.toDegrees（值[2]））;
如果（（int）的方向！=（int）的lastDirection）{
lastDirection =（int）的方向;
lastPitch =（int）的间距;
lastRoll =（INT）卷;
公共无效onAccuracyChanged（传感器传感器，精度INT）{
}};//规格化度为0至360，而不是-180至180私人诠释normalizeDegrees（双拉德）{
回报（INT）（（拉德+ 360）％360）;}//我们要忽略个别读数大的颠簸。所以，我们要盖度，我们可以每个报告更改号码私有静态最终诠释MAX_CHANGE = 3;私人诠释filterChange（INT NEWDIR）{
NEWDIR = normalizeDegrees（NEWDIR）;
//在一读，假设它是正确的。否则读数NW永远采取的增产行动
如果（firstReading）{
firstReading = FALSE;
返回NEWDIR;
//找出多少度移动
INT三角洲= NEWDIR
INT normalizedDelta = normalizeDegrees（增量）;
INT变化= Math.min（Math.abs（增量），MAX_CHANGE）;
//我们总是希望在更低的距离的方向移动。所以，如果NEWDIR较低，增量不到半圈，降低lastDir
//相同的，如果NEWDIR较高，但增量超过半圈（你会更快地在其他方向会更低）。
如果（normalizedDelta＆GT; 180）{
返回lastDirection +的变化;}公共无效的addListener（CompassListener监听）{
如果（listeners.size（）== 0）{
//开始对第一个监听计时器
handler.sendMessageDelayed（Message.obtain（处理器，1），1000）;
listeners.add（监听）;}公共无效的removeListener（CompassListener监听）{
listeners.remove（监听）;
如果（listeners.size（）== 0）{
handler.removeMessages（1）;
}}公众诠释getLastDirection（）{
返回lastD}公众诠释getLastPitch（）{
返回lastP}公众诠释getLastRoll（）{
返回lastP}私人无效callListeners（）{
对于（CompassListener监听器：监听器）{
listener.onDirectionChanged（lastDirection，lastPitch，lastRoll）;
}}//此处理程序正在运行的每1秒，并更新监听器//静态类，因为否则我们泄露，Eclipse的告诉我的静态类IncomingHandler扩展了Handler {
私人最终的WeakReference＆LT; CompassSensor＆GT; compassS
IncomingHandler（CompassSensor传感器）{
compassSensor =新的WeakReference＆LT; CompassSensor＆GT;（传感器）;
公共无效的handleMessage（消息MSG）
CompassSensor传感器= compassSensor.get（）;
如果（传感器！= NULL）{
sensor.callListeners（）;
sendMessageDelayed（Message.obtain（此，1），1000）;
}}IncomingHandler处理程序=新IncomingHandler（本）;公共接口CompassListener {
无效onDirectionChanged（INT方向，诠释俯仰，侧倾INT）;}}
本文地址： &
扫一扫关注官方微信陀螺仪与方向感应器_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
陀螺仪与方向感应器
阅读已结束，下载本文需要
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，方便使用
还剩12页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢咨询热线：400-883-3391
当前位置：
责任编辑：
ss.Write();
Jupiter SL871L-S是SL871L GNSS模块的GPS演变型，可同时支持GPS和QZSS并且与xL871家族(SL871L,SL871，SL871-S)的其他产品管脚兼容。SL871L-S还额外集成了LNA和DC单元，新增的LNA单元能够提高RF灵敏度，减少了TTFF时间；而DC单元则允许直接将主动天线输入信号进行无缝整合。SL871L-S通过标准UART接口输出定位数据，支持星历文件注入(A-GPS)和星级增强系统来提高精度，并且在任何情况下都具有低功耗的特点，专门进行优化以满足长时效电池应用。
内容最多500个汉字，1000个字符
1.尊重网上道德，遵守中华人民共和国的各项有关法律法规，不发表攻击性言论。
2.承担一切因您的行为而直接或间接导致的民事或刑事法律责任。
3.新闻留言板管理人员有权保留或删除其管辖留言中的任意内容。
2011 传感器传家网 Copyright All rights Recerviced
版权所有 2009 粤ICP备号supplierchannel