Mein Algorithmus zur Berechnung der Position des Smartphone - GPS und Sensoren

Wie einige von Euch erwähnt, du hast die Gleichungen falsch, aber das ist nur ein Teil der Fehler.

1. Newton - D ' Alembert Physik für nicht-relativistische Geschwindigkeiten bestimmt dieses:

   //init values
   double ax=0.0,ay=0.0,az=0.0; //acceleration [m/s^2]
   double vx=0.0,vy=0.0,vz=0.0; //velocity [m/s]
   double  x=0.0, y=0.0, z=0.0; //position [m]
   
   //iteration inside some timer (dt [seconds] period) ...
   ax,ay,az = accelerometer values
   vx+=ax*dt; //update speed via integration of acceleration
   vy+=ay*dt;
   vz+=az*dt;
    x+=vx*dt; //update position via integration of velocity
    y+=vy*dt;
    z+=vz*dt;

2. kann der sensor zu drehen, so Richtung angewendet werden müssen:

   //init values
   double gx=0.0,gy=-9.81,gz=0.0; //[edit1] background gravity in map coordinate system [m/s^2]
   double ax=0.0,ay=0.0,az=0.0; //acceleration [m/s^2]
   double vx=0.0,vy=0.0,vz=0.0; //velocity [m/s]
   double  x=0.0, y=0.0, z=0.0; //position [m]
   double dev[9]; //actual device transform matrix ... local coordinate system
   (x,y,z) <- GPS position;
   
   //iteration inside some timer (dt [seconds] period) ...
   dev <- compass direction
   ax,ay,az = accelerometer values (measured in device space)
   (ax,ay,az) = dev*(ax,ay,az);  //transform acceleration from device space to global map space without any translation to preserve vector magnitude
   ax-=gx;    //[edit1] remove background gravity (in map coordinate system)
   ay-=gy;
   az-=gz;
   vx+=ax*dt; //update speed (in map coordinate system)
   vy+=ay*dt;
   vz+=az*dt;
    x+=vx*dt; //update position (in map coordinate system)
    y+=vy*dt;
    z+=vz*dt;

   • gx,gy,gz ist die Globale Schwerkraft-Vektor (~9.81 m/s^2 auf der Erde)
   • im code meine Globale Y - Achse nach oben zeigt, damit die gy=-9.81 und der rest sind 0.0

3. Messen timings sind entscheidend,

   Beschleunigungssensor überprüft werden müssen, so oft wie möglich (die zweite ist eine sehr lange Zeit). Ich empfehle nicht, verwenden Sie timer-Periode größer als 10 ms zu erhalten die Genauigkeit auch Zeit zu Zeit sollten Sie überschreiben berechnete position mit dem GPS-Wert. Kompass Richtung kann überprüft werden, weniger oft, aber mit der richtigen filtration

4. Kompass ist nicht richtig, die ganze Zeit

   Kompass Werte gefiltert werden sollen für einige Spitzenwerte. Manchmal Las er schlechte Werte und kann auch ausgeschaltet werden durch Elektro-magnetischen Verschmutzung oder Metall-Umgebung. In diesem Fall wird die Richtung kontrolliert werden kann, die von GPS während der Bewegung und einige Korrekturen gemacht werden können. Zum Beispiel chech GPS jede minute und vergleichen die GPS-Richtung mit Kompass und, wenn es ständig von einigen Winkel dann hinzufügen oder subtrahieren.

5. warum einfache Berechnungen auf dem server ???

   Hate on-line Verschwendung von traffic. Ja, Sie können log-Daten auf dem server (aber trotzdem finde ich die Datei auf dem Gerät besser sein wird) aber warum zum Teufel limit position-Funktionalität, die von internet-Verbindung ??? nicht zu schweigen von den Verzögerungen ...

[Edit 1] zusätzliche Hinweise

Bearbeitet den code oben ein wenig. Die Ausrichtung muss so präzise sein, wie es sein kann, zu minimieren kumulativen Fehler.

Gyros hätte besser sein als der Kompass (oder noch besser beide). Beschleunigung gefiltert werden sollen. Einige low-pass-Filterung sollte in Ordnung sein. Nach der Schwerkraft die Entfernung würde ich begrenzen ax,ay,az zu brauchbaren Werten und wegwerfen zu kleine Werte. Wenn in der Nähe der niedrigen Geschwindigkeit auch voll stoppen (wenn es nicht ein Zug oder Bewegung im Vakuum). Das sollte geringer die drift, sondern erhöhen auch andere Fehler, so dass ein Kompromiss gefunden werden zwischen Ihnen.

Add-Kalibrierung on-the-fly. Wenn gefiltert acceleration = 9.81 oder sehr nah an ihm, dann ist das Gerät wahrscheinlich immer noch stehen (es sei denn, seine fliegende Maschine). Orientierung/Richtung kann korrigiert werden, indem die tatsächliche Schwerkraft-Richtung.

InformationsquelleAutor Spektre

Nach der Lösung die position, die ich berechnet über Sensoren, die würde ich gerne poste meinen code hier ein, falls jemand braucht in Zukunft:

Anmerkung: Dies wurde nur geprüft auf Samsung Galaxy S2 Handy und nur, wenn die person war zu Fuß mit dem Handy, es wurde nicht geprüft, wenn bewegliche, im Auto oder auf dem Fahrrad

Dies ist das Ergebnis bekam ich, als im Vergleich bei einem Vergleich mit GPS (Rote Linie GPS, Blau ist, ist die Position berechnet, mit Sensor)

Der code ist nicht sehr effizient, aber ich hoffe, dass mein Austausch in diesem code jemand helfen und zeigen Sie in die richtige Richtung.

Hatte ich zwei getrennte Klassen:

1. CalculatePosition

2. CustomSensorService

   public class CalculatePosition {

           static Double earthRadius = 6378D;
           static Double oldLatitude,oldLongitude;
           static Boolean IsFirst = true;
   
           static Double sensorLatitude, sensorLongitude;
   
           static Date CollaborationWithGPSTime;
           public static float[] results;
   
   
   
           public static void calculateNewPosition(Context applicationContext,
                   Float currentAcceleration, Float currentSpeed,
                   Float currentDistanceTravelled, Float currentDirection, Float TotalDistance) {
   
   
               results = new float[3];
               if(IsFirst){
                   CollaborationWithGPSTime = new Date();
                   Toast.makeText(applicationContext, "First", Toast.LENGTH_LONG).show();
                   oldLatitude = CustomLocationListener.mLatitude;
                   oldLongitude = CustomLocationListener.mLongitude;
                   sensorLatitude = oldLatitude;
                   sensorLongitude = oldLongitude;
                   LivePositionActivity.PlotNewPosition(oldLongitude,oldLatitude,currentDistanceTravelled * 1000, currentAcceleration, currentSpeed, currentDirection, "GPSSensor",0.0F,TotalDistance);
                   IsFirst  = false;
                   return;
               } 
   
               Date CurrentDateTime = new Date();
   
               if(CurrentDateTime.getTime() - CollaborationWithGPSTime.getTime() > 900000){
                   //This IF Statement is to Collaborate with GPS position --> For accuracy --> 900,000 == 15 minutes
                   oldLatitude = CustomLocationListener.mLatitude;
                   oldLongitude = CustomLocationListener.mLongitude;
                   LivePositionActivity.PlotNewPosition(oldLongitude,oldLatitude,currentDistanceTravelled * 1000, currentAcceleration, currentSpeed, currentDirection, "GPSSensor", 0.0F, 0.0F);
                   return;
               }
   
               //Convert Variables to Radian for the Formula
               oldLatitude = Math.PI * oldLatitude / 180;
               oldLongitude = Math.PI * oldLongitude / 180;
               currentDirection = (float) (Math.PI * currentDirection / 180.0);
   
               //Formulae to Calculate the NewLAtitude and NewLongtiude
               Double newLatitude = Math.asin(Math.sin(oldLatitude) * Math.cos(currentDistanceTravelled / earthRadius) + 
                       Math.cos(oldLatitude) * Math.sin(currentDistanceTravelled / earthRadius) * Math.cos(currentDirection));
               Double newLongitude = oldLongitude + Math.atan2(Math.sin(currentDirection) * Math.sin(currentDistanceTravelled / earthRadius)
                       * Math.cos(oldLatitude), Math.cos(currentDistanceTravelled / earthRadius)
                       - Math.sin(oldLatitude) * Math.sin(newLatitude));
   
               //Convert Back from radians
               newLatitude = 180 * newLatitude / Math.PI;
               newLongitude = 180 * newLongitude / Math.PI;
               currentDirection = (float) (180 * currentDirection / Math.PI);
   
               //Update old Latitude and Longitude
               oldLatitude = newLatitude;
               oldLongitude = newLongitude;
   
               sensorLatitude = oldLatitude;
               sensorLongitude = oldLongitude;
   
               IsFirst = false;
               //Plot Position on Map
               LivePositionActivity.PlotNewPosition(newLongitude,newLatitude,currentDistanceTravelled * 1000, currentAcceleration, currentSpeed, currentDirection, "Sensor", results[0],TotalDistance);
   
   
   
   
   
       }
   }

   public class CustomSensorService extends Service implements SensorEventListener{

   static SensorManager sensorManager;
   static Sensor mAccelerometer;
   private Sensor mMagnetometer;
   private Sensor mLinearAccelertion;
   
   static Context mContext;
   
   private static float[] AccelerometerValue;
   private static float[] MagnetometerValue;
   
   public static  Float currentAcceleration = 0.0F;
   public static  Float  currentDirection = 0.0F;
   public static Float CurrentSpeed = 0.0F;
   public static Float CurrentDistanceTravelled = 0.0F;
   /*---------------------------------------------*/
   float[] prevValues,speed;
   float[] currentValues;
   float prevTime, currentTime, changeTime,distanceY,distanceX,distanceZ;
   float[] currentVelocity;
   public static CalculatePosition CalcPosition;
   /*-----FILTER VARIABLES-------------------------*-/
    * 
    * 
    */
   
   public static Float prevAcceleration = 0.0F;
   public static Float prevSpeed = 0.0F;
   public static Float prevDistance = 0.0F;
   
   public static Float totalDistance;
   
   TextView tv;
   Boolean First,FirstSensor = true;
   
   @Override
   public void onCreate(){
   
       super.onCreate();
       mContext = getApplicationContext();
       CalcPosition =  new CalculatePosition();
       First = FirstSensor = true;
       currentValues = new float[3];
       prevValues = new float[3];
       currentVelocity = new float[3];
       speed = new float[3];
       totalDistance = 0.0F;
       Toast.makeText(getApplicationContext(),"Service Created",Toast.LENGTH_SHORT).show();
   
       sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
   
       mAccelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
       mMagnetometer = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
       //mGyro = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
       mLinearAccelertion = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);
   
       sensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_NORMAL);
       sensorManager.registerListener(this, mMagnetometer, SensorManager.SENSOR_DELAY_NORMAL);
       //sensorManager.registerListener(this, mGyro, SensorManager.SENSOR_DELAY_NORMAL);
       sensorManager.registerListener(this, mLinearAccelertion, SensorManager.SENSOR_DELAY_NORMAL);
   
   }
   
   @Override
   public void onDestroy(){
       Toast.makeText(this, "Service Destroyed", Toast.LENGTH_SHORT).show();
       sensorManager.unregisterListener(this);
       //sensorManager = null;
       super.onDestroy();
   }
   @Override
   public void onAccuracyChanged(Sensor sensor, int accuracy) {
       //TODO Auto-generated method stub
   
   }
   
   @Override
   public void onSensorChanged(SensorEvent event) {
   
       float[] values = event.values;
       Sensor mSensor = event.sensor;
   
       if(mSensor.getType() == Sensor.TYPE_ACCELEROMETER){
           AccelerometerValue = values;
       }
   
       if(mSensor.getType() == Sensor.TYPE_LINEAR_ACCELERATION){           
           if(First){
               prevValues = values;
               prevTime = event.timestamp / 1000000000;
               First = false;
               currentVelocity[0] = currentVelocity[1] = currentVelocity[2] = 0;
               distanceX = distanceY= distanceZ = 0;
           }
           else{
               currentTime = event.timestamp / 1000000000.0f;
   
               changeTime = currentTime - prevTime;
   
               prevTime = currentTime;
   
   
   
               calculateDistance(event.values, changeTime);
   
               currentAcceleration =  (float) Math.sqrt(event.values[0] * event.values[0] + event.values[1] * event.values[1] + event.values[2] * event.values[2]);
   
               CurrentSpeed = (float) Math.sqrt(speed[0] * speed[0] + speed[1] * speed[1] + speed[2] * speed[2]);
               CurrentDistanceTravelled = (float) Math.sqrt(distanceX *  distanceX + distanceY * distanceY +  distanceZ * distanceZ);
               CurrentDistanceTravelled = CurrentDistanceTravelled / 1000;
   
               if(FirstSensor){
                   prevAcceleration = currentAcceleration;
                   prevDistance = CurrentDistanceTravelled;
                   prevSpeed = CurrentSpeed;
                   FirstSensor = false;
               }
               prevValues = values;
   
           }
       }
   
       if(mSensor.getType() == Sensor.TYPE_MAGNETIC_FIELD){
           MagnetometerValue = values;
       }
   
       if(currentAcceleration != prevAcceleration || CurrentSpeed != prevSpeed || prevDistance != CurrentDistanceTravelled){
   
           if(!FirstSensor)
               totalDistance = totalDistance + CurrentDistanceTravelled * 1000;
           if (AccelerometerValue != null && MagnetometerValue != null && currentAcceleration != null) {
               //Direction
               float RT[] = new float[9];
               float I[] = new float[9];
               boolean success = SensorManager.getRotationMatrix(RT, I, AccelerometerValue,
                       MagnetometerValue);
               if (success) {
                   float orientation[] = new float[3];
                   SensorManager.getOrientation(RT, orientation);
                   float azimut = (float) Math.round(Math.toDegrees(orientation[0]));
                   currentDirection =(azimut+ 360) % 360;
                   if( CurrentSpeed > 0.2){
                       CalculatePosition.calculateNewPosition(getApplicationContext(),currentAcceleration,CurrentSpeed,CurrentDistanceTravelled,currentDirection,totalDistance);
                   }
               }
               prevAcceleration = currentAcceleration;
               prevSpeed = CurrentSpeed;
               prevDistance = CurrentDistanceTravelled;
           }
       }
   
   }
   
   
   @Override
   public IBinder onBind(Intent arg0) {
       //TODO Auto-generated method stub
       return null;
   }
   public void calculateDistance (float[] acceleration, float deltaTime) {
       float[] distance = new float[acceleration.length];
   
       for (int i = 0; i < acceleration.length; i++) {
           speed[i] = acceleration[i] * deltaTime;
           distance[i] = speed[i] * deltaTime + acceleration[i] * deltaTime * deltaTime / 2;
       }
       distanceX = distance[0];
       distanceY = distance[1];
       distanceZ = distance[2];
   }

   }

EDIT:

public static void PlotNewPosition(Double newLatitude, Double newLongitude, Float currentDistance, 
        Float currentAcceleration, Float currentSpeed, Float currentDirection, String dataType) {

    LatLng newPosition = new LatLng(newLongitude,newLatitude);

    if(dataType == "Sensor"){
        tvAcceleration.setText("Speed: " + currentSpeed + " Acceleration: " + currentAcceleration + " Distance: " + currentDistance +" Direction: " + currentDirection + " \n"); 
        map.addMarker(new MarkerOptions()
        .position(newPosition)
        .title("Position")
        .snippet("Sensor Position")
        .icon(BitmapDescriptorFactory
                .fromResource(R.drawable.line)));
    }else if(dataType == "GPSSensor"){
        map.addMarker(new MarkerOptions()
        .position(newPosition)
        .title("PositionCollaborated")
        .snippet("GPS Position"));
    }
    else{
        map.addMarker(new MarkerOptions()
        .position(newPosition)
        .title("Position")
        .snippet("New Position")
        .icon(BitmapDescriptorFactory
                .fromResource(R.drawable.linered)));
    }
    map.moveCamera(CameraUpdateFactory.newLatLngZoom(newPosition, 18));
}

InformationsquelleAutor Dawood Awan

Ich bin nicht ganz sicher, aber meine beste Vermutung wäre, um dieses Teil:

Double initialVelocity = prevLocation.Speed;
var t = secondsTravelling.TotalSeconds;
var finalvelocity = initialVelocity + Double.Parse(currentAcceleration) * t;

wenn sagen wir um die prevLocation die Geschwindigkeit wurde: 27.326... und t==0 und currentAcceleration ==0 (als Sie sagten, Sie waren im Leerlauf) die finalvelocity kommen würde, auf

var finalvelocity = 27.326 + 0*0;
var finalvelocity == 27.326

Wenn die finalvelocity wird die Geschwindigkeit der currentlocation, so dass previouslocation = currentlocation. Dies würde bedeuten, dass Ihre finalvelocity kann nicht nach unten gehen. Aber dann wieder, es ist schon ein bisschen von Annahmen hier.

InformationsquelleAutor CuccoChaser