Возможно ли, чтобы скорость движения и скорость транспортного средства была увеличена до ускорения и угла рыскания в NED [дубликат]

В соответствии с нашим обсуждением, так как ваше ускорение непрерывно изменяется, принятые вами уравнения не должны давать вам точного ответа.

Возможно, вам придется постоянно обновлять свои позиции и скорости как и когда вы получаете новое чтение для ускорения.

Поскольку это было бы крайне неэффективно, моим предложением было бы вызвать функцию обновления каждые несколько секунд и использовать среднее значение ускорения в течение этого периода, чтобы получить новую скорость и положение.

Датчики ускорения и гироскопы не подходят для расчета положения. Через несколько секунд ошибки становятся невероятно высокими. (Я почти не помню, что двойная интеграция является проблемой). Посмотрите на это текстовое видео Google о слиянии датчиков, он очень подробно объясняет, почему это невозможно.

Я не совсем уверен, но мое лучшее предположение было бы вокруг этой части:

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

, если можно сказать, что в prevLocation скорость была: 27.326 ... и t == 0 и currentAcceleration == 0 (как вы сказали, что вы простаиваете) окончательное значение спустится до

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

Если конечная скорость становится скоростью текущего местоположения, так что предыдущая локация = текущая локация. Это означало бы, что ваша окончательная цена может не снизиться. Но опять же, здесь есть несколько предположений.

Похоже, вы делаете это на себя. Вы должны иметь возможность просто использовать API местоположения сервисов Google Play и легко получить доступ к местоположению, направлению, скорости и т. Д.

Я бы изучил использование этого вместо того, чтобы выполнять работу серверная сторона для него.

После решения позиции, которую я вычислил с помощью датчиков, я хотел бы опубликовать свой код здесь, если кому-то понадобится в будущем:

Примечание: Это было проверено только на телефоне Samsung Galaxy S2 и только когда человек шел с телефоном он не тестировался при движении в автомобиле или на велосипеде

[/g0]

. Это результат, который я получил при сравнении по сравнению с GPS, (Red Line GPS, Blue - позиция, рассчитанная с помощью датчика)

Код не очень эффективен, но я надеюсь, что мой общий доступ к этому коду поможет кому-то и укажет их в правильном направлении.

У меня было два отдельных класса:

1. CalculatePosition
2. PublicSensorService 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 Сервис реализует 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));
}