如何在android中實現陀螺儀傳感器？

Question

我正在嘗試編寫陀螺儀的最簡單實現（僅在更改屏幕時記錄屏幕的方向）。有人能提供一個簡單的例子嗎？

---

這就是我想現在：

public class LessonFiveGLSurfaceView extends GLSurfaceView implements SensorEventListener 
     { 
     private LessonFiveRenderer mRenderer; 

     public LessonFiveGLSurfaceView(Context context) 
     { 
      super(context); 
      System.out.println("test"); 
     } 
     @Override 
     public void onSensorChanged(SensorEvent event) 
     { 
      //output the Roll, Pitch and Yawn values 
      System.out.println("Orientation X (Roll) :"+ Float.toString(event.values[2]) +"\n"+ 
         "Orientation Y (Pitch) :"+ Float.toString(event.values[1]) +"\n"+ 
         "Orientation Z (Yaw) :"+ Float.toString(event.values[0])); 
     } 

但是我得到錯誤：「類型LessonFiveGLSurfaceView必須實現繼承的抽象方法SensorEventListener.onAccuracyChanged（傳感器，INT）」 。

Answer 1

在這裏，我想出了一個類來吸引使用在Android的陀螺儀傳感器它會平滑輸入數據一點，以及平板電腦和手機沒有相同的自然方向（電話是在肖像，而平板電腦在橫向）：

/** 
* Uses the sensor API to determine the phones orientation. 
* Registering for events from the accelerator and the magnetometer (compass) 
* a rotation matrix is computed. This matrix can be used to rotate an 
* OpenGL scene. 
*/ 
public class PhoneGyroscope implements SensorEventListener{ 
private static final String TAG = PhoneGyroscope.class.getSimpleName(); 
private SensorManager mSensorManager; 
private WindowManager mWindowManager; 
private float[] mAccelGravityData = new float[3]; 
private float[] mGeomagneticData = new float[3]; 
private float[] mRotationMatrix = new float[16]; 
private float[] bufferedAccelGData = new float[3]; 
private float[] bufferedMagnetData = new float[3]; 

public PhoneGyroscope(Context context) { 
    mSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE); 
    mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE); 
} 

public void start() { 
    mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_GAME); 
    mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD), SensorManager.SENSOR_DELAY_GAME); 
} 

public void stop() { 
    mSensorManager.unregisterListener(this); 
} 

private void loadNewSensorData(SensorEvent event) { 
    final int type = event.sensor.getType(); 
    if (type == Sensor.TYPE_ACCELEROMETER) { 
     //Smoothing the sensor data a bit 
     mAccelGravityData[0]=(mAccelGravityData[0]*2+event.values[0])*0.33334f; 
     mAccelGravityData[1]=(mAccelGravityData[1]*2+event.values[1])*0.33334f; 
     mAccelGravityData[2]=(mAccelGravityData[2]*2+event.values[2])*0.33334f; 
    } 
    if (type == Sensor.TYPE_MAGNETIC_FIELD) { 
     //Smoothing the sensor data a bit 
     mGeomagneticData[0]=(mGeomagneticData[0]*1+event.values[0])*0.5f; 
     mGeomagneticData[1]=(mGeomagneticData[1]*1+event.values[1])*0.5f; 
     mGeomagneticData[2]=(mGeomagneticData[2]*1+event.values[2])*0.5f; 

     float x = mGeomagneticData[0]; 
     float y = mGeomagneticData[1]; 
     float z = mGeomagneticData[2]; 
     double field = Math.sqrt(x*x+y*y+z*z); 
     if (field>25 && field<65){ 
      Log.e(TAG, "loadNewSensorData : wrong magnetic data, need a recalibration field = " + field); 
     } 
    } 
} 


private void rootMeanSquareBuffer(float[] target, float[] values) { 

    final float amplification = 200.0f; 
    float buffer = 20.0f; 

    target[0] += amplification; 
    target[1] += amplification; 
    target[2] += amplification; 
    values[0] += amplification; 
    values[1] += amplification; 
    values[2] += amplification; 

    target[0] = (float) (Math 
      .sqrt((target[0] * target[0] * buffer + values[0] * values[0]) 
        /(1 + buffer))); 
    target[1] = (float) (Math 
      .sqrt((target[1] * target[1] * buffer + values[1] * values[1]) 
        /(1 + buffer))); 
    target[2] = (float) (Math 
      .sqrt((target[2] * target[2] * buffer + values[2] * values[2]) 
        /(1 + buffer))); 

    target[0] -= amplification; 
    target[1] -= amplification; 
    target[2] -= amplification; 
    values[0] -= amplification; 
    values[1] -= amplification; 
    values[2] -= amplification; 
} 


/* 
* Tablets have LANDSCAPE as default orientation, so screen rotation is 0 or 180 when the orientation is LANDSCAPE, and smartphones have PORTRAIT. 
* I use the next code to difference between tablets and smartphones: 
*/ 
public static int getScreenOrientation(Display display){ 
    int orientation; 

    if(display.getWidth()==display.getHeight()){ 
     orientation = Configuration.ORIENTATION_SQUARE; 
    }else{ //if width is less than height than it is portrait 
     if(display.getWidth() < display.getHeight()){ 
      orientation = Configuration.ORIENTATION_PORTRAIT; 
     }else{ // if it is not any of the above it will definitly be landscape 
      orientation = Configuration.ORIENTATION_LANDSCAPE; 
     } 
    } 
    return orientation; 
} 

private void debugSensorData(SensorEvent event) { 
    StringBuilder builder = new StringBuilder(); 
    builder.append("--- SENSOR ---"); 
    builder.append("\nName: "); 
    Sensor sensor = event.sensor; 
    builder.append(sensor.getName()); 
    builder.append("\nType: "); 
    builder.append(sensor.getType()); 
    builder.append("\nVendor: "); 
    builder.append(sensor.getVendor()); 
    builder.append("\nVersion: "); 
    builder.append(sensor.getVersion()); 
    builder.append("\nMaximum Range: "); 
    builder.append(sensor.getMaximumRange()); 
    builder.append("\nPower: "); 
    builder.append(sensor.getPower()); 
    builder.append("\nResolution: "); 
    builder.append(sensor.getResolution()); 

    builder.append("\n\n--- EVENT ---"); 
    builder.append("\nAccuracy: "); 
    builder.append(event.accuracy); 
    builder.append("\nTimestamp: "); 
    builder.append(event.timestamp); 
    builder.append("\nValues:\n"); 
    for (int i = 0; i < event.values.length; i++) { 
     // ... 
     builder.append(" ["); 
     builder.append(i); 
     builder.append("] = "); 
     builder.append(event.values[i]); 
     builder.append("\n"); 
    } 

    Log.d(TAG, builder.toString()); 
} 

@Override 
public void onAccuracyChanged(Sensor sensor, int accuracy) { 
    // TODO Auto-generated method stub 

} 

/* Sensor Processing/Rotation Matrix 
* Each time a sensor update happens the onSensorChanged method is called. 
* This is where we receive the raw sensor data. 
* First of all we want to take the sensor data from the accelerometer and magnetometer and smooth it out to reduce jitters. 
* From there we can call the getRotationMatrix function with our smoothed accelerometer and magnetometer data. 
* The rotation matrix that this outputs is mapped to have the y axis pointing out the top of the phone, so when the phone is flat on a table facing north, it will read {0,0,0}. 
* We need it to read {0,0,0} when pointing north, but sitting vertical. To achieve this we simply remap the co-ordinates system so the X axis is negative. 
* The following code example shows how this is acheived. 
*/ 
@Override 
public void onSensorChanged(SensorEvent event) { 

    if (event.accuracy == SensorManager.SENSOR_STATUS_UNRELIABLE) { 
     return; 
    } 

    loadNewSensorData(event); 
    int type=event.sensor.getType(); 

    if (mAccelGravityData != null && mGeomagneticData != null) { 

     if ((type==Sensor.TYPE_MAGNETIC_FIELD) || (type==Sensor.TYPE_ACCELEROMETER)) { 
      rootMeanSquareBuffer(bufferedAccelGData, mAccelGravityData); 
      rootMeanSquareBuffer(bufferedMagnetData, mGeomagneticData); 
      if (SensorManager.getRotationMatrix(mRotationMatrix, null, bufferedAccelGData, bufferedMagnetData)){ 

       Display display = mWindowManager.getDefaultDisplay(); 
       int orientation = getScreenOrientation(display); 
       int rotation = display.getRotation(); 

       boolean dontRemapCoordinates = (orientation == Configuration.ORIENTATION_LANDSCAPE && rotation == Surface.ROTATION_0) || 
         (orientation == Configuration.ORIENTATION_LANDSCAPE && rotation == Surface.ROTATION_180) || 
         (orientation == Configuration.ORIENTATION_PORTRAIT && rotation == Surface.ROTATION_90) || 
         (orientation == Configuration.ORIENTATION_PORTRAIT && rotation == Surface.ROTATION_270); 

       if(!dontRemapCoordinates){ 
            SensorManager.remapCoordinateSystem(
              mRotationMatrix, 
              SensorManager.AXIS_Y, 
              SensorManager.AXIS_MINUS_X, 
              mRotationMatrix); 
       } 
       debugSensorData(event); 
      } 
     }  
    } 

} 
} 

Answer 2

SensorEventListener接口有2個函數。你需要實現兩者。你可以讓這個函數什麼也不做，但你仍然需要實現它。