दिलचस्प पोस्ट
एकल पृष्ठ एप्लिकेशन – आंशिक दृश्य के आधार पर गतिशील रूप से लोड जेएस फ़ाइल WPF में एक वेक्टर छवि का उपयोग करने का सबसे अच्छा तरीका है? ES6 वर्गों के साथ फ़ंक्शन कैसे बढ़ाएं? Android स्टूडियो वास्तविक डिवाइस पर एप्लिकेशन चलाने के बाद अवांछित अनुमति जोड़ता है मैं स्वचालित रूप से एक यूट्यूब वीडियो (IFrame API) को कैसे म्यूट करूँ? अपाचे एचटीटीपी क्लाइंट 4.0.3 – मैं POST अनुरोध के लिए sessionID के साथ कुकी कैसे सेट करूँ? तालिका में पहचान स्तंभ के लिए एक स्पष्ट मान केवल निर्दिष्ट किया जा सकता है जब एक स्तंभ सूची का उपयोग किया जाता है और IDENTITY_INSERT पर SQL सर्वर है Onclick घटना नहीं jsfiddle.net पर फायरिंग MySQL JDBC ड्राइवर कनेक्शन स्ट्रिंग क्या है? जावास्क्रिप्ट में {} या नया ऑब्जेक्ट () के साथ एक खाली ऑब्जेक्ट बनाएँ? अनचेक वाले चेकबॉक्स को पोस्ट करें कौन सा प्रदर्शनकर्ता, सीटीई या अस्थायी तालिकाओं हैं? पिकासो v / s Imageloader v / s फ्रेस्को वि ग्लाइड क्या मैं एक: पहले या: एक इनपुट फ़ील्ड पर छद्म तत्व के बाद उपयोग कर सकता हूं? इनर ज्वाइन पर क्रॉस एप्लाई कब लगाना चाहिए?

स्मार्टफोन की स्थिति की गणना करने के लिए मेरा एल्गोरिथ्म – जीपीएस और सेंसर

मैं सेंसर के डेटा पर आधारित स्थिति की गणना करने के लिए एक एंड्रॉइड एप्लिकेशन विकसित कर रहा हूं

  1. एक्सेलेरोमीटर -> रैखिक त्वरण की गणना करें

  2. मैगनेटोमीटर + एक्सीलरोमीटर – आंदोलन की दिशा

प्रारंभिक स्थिति जीपीएस से ली जाएगी (अक्षांश + देशांतर)

अब सेंसर के पाठ पर आधारित मुझे स्मार्टफोन की नई स्थिति की गणना करने की आवश्यकता है:

मेरा एल्गोरिथम निम्नलिखित है – (लेकिन सटीक स्थिति की गणना नहीं है): कृपया इसे सुधारने में मेरी मदद करें।

नोट: मेरा एल्गोरिथ्म कोड सी # में है (मैं सर्वर से सेंसर डेटा भेज रहा हूं – जहां डेटा डाटाबेस में संग्रहीत होता है। मैं सर्वर पर स्थिति की गणना कर रहा हूँ)

01-01-19 70 से टाइमस्टैम्प से सभी डेटटाइम ऑब्जेक्ट्स की गणना की गई है

var prevLocation = ServerHandler.getLatestPosition(IMEI); var newLocation = new ReceivedDataDTO() { LocationDataDto = new LocationDataDTO(), UsersDto = new UsersDTO(), DeviceDto = new DeviceDTO(), SensorDataDto = new SensorDataDTO() }; //First Reading if (prevLocation.Latitude == null) { //Save GPS Readings newLocation.LocationDataDto.DeviceId = ServerHandler.GetDeviceIdByIMEI(IMEI); newLocation.LocationDataDto.Latitude = Latitude; newLocation.LocationDataDto.Longitude = Longitude; newLocation.LocationDataDto.Acceleration = float.Parse(currentAcceleration); newLocation.LocationDataDto.Direction = float.Parse(currentDirection); newLocation.LocationDataDto.Speed = (float) 0.0; newLocation.LocationDataDto.ReadingDateTime = date; newLocation.DeviceDto.IMEI = IMEI; // saving to database ServerHandler.SaveReceivedData(newLocation); return; } //If Previous Position not NULL --> Calculate New Position **//Algorithm Starts HERE** var oldLatitude = Double.Parse(prevLocation.Latitude); var oldLongitude = Double.Parse(prevLocation.Longitude); var direction = Double.Parse(currentDirection); Double initialVelocity = prevLocation.Speed; //Get Current Time to calculate time Travelling - In seconds var secondsTravelling = date - tripStartTime; var t = secondsTravelling.TotalSeconds; //Calculate Distance using physice formula, s= Vi * t + 0.5 * a * t^2 // distanceTravelled = initialVelocity * timeTravelling + 0.5 * currentAcceleration * timeTravelling * timeTravelling; var distanceTravelled = initialVelocity * t + 0.5 * Double.Parse(currentAcceleration) * t * t; //Calculate the Final Velocity/ Speed of the device. // this Final Velocity is the Initil Velocity of the next reading //Physics Formula: Vf = Vi + a * t var finalvelocity = initialVelocity + Double.Parse(currentAcceleration) * t; //Convert from Degree to Radians (For Formula) oldLatitude = Math.PI * oldLatitude / 180; oldLongitude = Math.PI * oldLongitude / 180; direction = Math.PI * direction / 180.0; //Calculate the New Longitude and Latitude var newLatitude = Math.Asin(Math.Sin(oldLatitude) * Math.Cos(distanceTravelled / earthRadius) + Math.Cos(oldLatitude) * Math.Sin(distanceTravelled / earthRadius) * Math.Cos(direction)); var newLongitude = oldLongitude + Math.Atan2(Math.Sin(direction) * Math.Sin(distanceTravelled / earthRadius) * Math.Cos(oldLatitude), Math.Cos(distanceTravelled / earthRadius) - Math.Sin(oldLatitude) * Math.Sin(newLatitude)); //Convert From Radian to degree/Decimal newLatitude = 180 * newLatitude / Math.PI; newLongitude = 180 * newLongitude / Math.PI; 

यह मेरा परिणाम है -> फोन नहीं चल रहा था। जैसा कि आप गति देख सकते हैं 27.3263111114502 है इसलिए गति की गणना में कुछ गड़बड़ है लेकिन मैं नहीं जानता कि क्या है

यहां छवि विवरण दर्ज करें

उत्तर:

मुझे सेंसर पर आधारित स्थिति की गणना करने का समाधान मिला: मैंने नीचे एक उत्तर पोस्ट किया है।

अगर आपको किसी भी मदद की ज़रूरत है, तो कृपया एक टिप्पणी छोड़ दें

यह जीपीएस की तुलना में परिणाम है ( नोट: जीपीएस लाल रंग में है)

यहां छवि विवरण दर्ज करें

वेब के समाधान से एकत्रित समाधान "स्मार्टफोन की स्थिति की गणना करने के लिए मेरा एल्गोरिथ्म – जीपीएस और सेंसर"

जैसा कि आप में से कुछ ने कहा है कि आपको समीकरण गलत हैं, लेकिन यह सिर्फ त्रुटि का एक हिस्सा है।

  1. न्यूटोन-डी लैंबर्ट भौतिकी गैर सापेक्ष गति के लिए यह निर्धारित करता है:

     // 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. सेंसर बारी बारी से तो दिशा लागू किया जाना चाहिए कर सकते हैं:

     // 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 वैश्विक गुरुत्वाकर्षण वेक्टर ( ~9.81 m/s^2 पृथ्वी पर है)
    • कोड में मेरी वैश्विक Y अक्ष ऊपर की gy=-9.81 , इसलिए gy=-9.81 और बाकी 0.0
  3. उपाय समय महत्वपूर्ण हैं

    एक्सेलेरोमीटर को जितनी बार संभव हो, जांचना चाहिए (दूसरा बहुत लंबा समय है)। मैं अनुशंसा करता हूं कि सटीकता को बनाए रखने के लिए 10 एमएस से बड़ा टाइमर अवधि का उपयोग न करें, समय पर आपको जीपीएस मूल्य के साथ गणना की स्थिति को ओवरराइड करना चाहिए। कम्पास की दिशा कम बार की जांच की जा सकती है लेकिन उचित निस्पंदन के साथ

  4. कम्पास हर समय सही नहीं है

    कम्पास मूल्यों को कुछ चोटी के मूल्यों के लिए फ़िल्टर्ड किया जाना चाहिए। कभी-कभी यह खराब मूल्यों को पढ़ता है और इलेक्ट्रो-चुंबकीय पोषण या धातु के वातावरण से भी बंद हो सकता है। उस मामले में आंदोलन के दौरान जीपीएस द्वारा दिशा की जांच की जा सकती है और कुछ सुधार किए जा सकते हैं। उदाहरण के लिए हर बार चेच जीपीएस को और कम्पास के साथ जीपीएस दिशा की तुलना करें और अगर यह किसी कोण से लगातार होता है तो उसे जोड़ दें या उसे घटाना

  5. सर्वर पर सरल संगणना क्यों करते हैं ???

    नफरत यातायात पर लाइन अपशिष्ट हां, आप सर्वर पर डेटा लॉग कर सकते हैं (लेकिन फिर भी मुझे लगता है कि डिवाइस पर फ़ाइल बेहतर होगा) लेकिन इंटरनेट कनेक्टिविटी द्वारा सीमित स्थिति की कार्यक्षमता क्यों है ??? देरी का उल्लेख नहीं करने के लिए …

[संपादित करें 1] अतिरिक्त नोट्स

थोड़ा ऊपर कोड संपादित उन्मुखीकरण सटीक होना चाहिए क्योंकि यह संचयी त्रुटियों को कम करने के लिए किया जा सकता है।

Gyros कम्पास से बेहतर होगा (या उससे बेहतर दोनों का उपयोग करें) त्वरण को फ़िल्टर किया जाना चाहिए। कुछ कम पास फ़िल्टरिंग ठीक होनी चाहिए गुरुत्वाकर्षण को हटाने के बाद मैं कुल्हाड़ी, एआई, एज़ को उपयोगी मूल्यों तक सीमित कर दूंगा और बहुत कम मूल्यों को दूर कर दूंगा। यदि कम गति के निकट भी पूर्ण स्टॉप (यदि यह ट्रेन या वैक्यूम में गति नहीं है) करता है यह बहाव को कम करना चाहिए, लेकिन अन्य त्रुटियों को बढ़ाएं ताकि उनके बीच एक समझौता हो।

उड़ने पर अंशांकन जोड़ें जब फ़िल्टर्ड acceleration = 9.81 या इसके बहुत करीब है तो डिवाइस शायद अभी भी खड़ा है (जब तक कि इसकी उड़ान मशीन नहीं)। ओरिएंटेशन / दिशा वास्तविक गुरुत्व दिशा से ठीक किया जा सकता है।

त्वरण सेंसर और जीरोस स्थिति गणना के लिए अनुकूल नहीं हैं।
कुछ सेकंड के बाद त्रुटियां अविश्वसनीय उच्च हो जाती हैं (मुझे शायद ही याद है कि डबल एकीकरण समस्या है)।
सेंसर फ्यूजनिंग के बारे में इस Google टेक टॉक वीडियो को देखें, वह बहुत विस्तार से बताते हैं कि यह संभव क्यों नहीं है।

स्थिति को हल करने के बाद मैं सेंसर का उपयोग करके गणना करता हूं, मैं भविष्य में किसी की जरूरत के मामले में अपना कोड यहां पोस्ट करना चाहता हूं:

नोट: यह केवल सैमसंग गैलेक्सी एस 2 फोन पर चेक किया गया था और केवल जब व्यक्ति फोन के साथ चल रहा था, कार में या बाइक पर जाने के दौरान यह परीक्षण नहीं किया गया है

जीपीएस के मुकाबले इस तुलना में मुझे जो परिणाम मिला है, (रेड लाइन जीपीएस, नीली स्थिति सेंसर के साथ गणना की गई है)

जीपीएस के मुकाबले इस तुलना में मुझे जो परिणाम मिला है, (रेड लाइन जीपीएस, नीली स्थिति सेंसर के साथ गणना की गई है)

कोड बहुत ही कुशल नहीं है, लेकिन मुझे आशा है कि यह साझा करने के लिए यह कोड किसी की मदद करेगी और उन्हें सही दिशा में बताएगी।

मेरे दो अलग-अलग कक्षाएं थीं:

  1. CalculatePosition
  2. CustomSensorService

    सार्वजनिक श्रेणी की गणना करें {

      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); } } 

    पब्लिक क्लास कस्टमसेंसर सेवा सर्विस उपकरण लागू करती है सेंसरइवेंट एलिसर {

     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]; } 

    }

संपादित करें:

 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)); } 

हमारी चर्चा के अनुसार, जब से आपका त्वरण लगातार बदल रहा है, आपके द्वारा लागू किए गए प्रस्ताव के समीकरण आपको सटीक उत्तर नहीं देंगे।

आपको अपनी स्थिति और वेग को अद्यतन करना पड़ सकता है और जब आप त्वरण के लिए एक नया रीडिंग प्राप्त करते हैं।

चूंकि यह बेहद अक्षम है, मेरा सुझाव हर कुछ सेकंड में अपडेट फ़ंक्शन को कॉल करना होगा और नए वेग और स्थिति को प्राप्त करने के लिए उस अवधि के दौरान त्वरण के औसत मूल्य का उपयोग करना होगा।

मुझे पूरी तरह यकीन नहीं है, लेकिन मेरा सबसे अच्छा अनुमान इस भाग के आसपास होगा:

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

अगर हम आगे वाले स्थान पर गति कहते हैं: 27.326 … और टी == 0 और वर्तमान परिसर == 0 (जैसा आपने कहा था कि आप बेकार थे) अंतिम असत्यता नीचे आ जाएगी

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

यदि अंतिम वास्तविकता वर्तमान स्थान की गति हो जाती है, तो पिछले स्थान = वर्तमान स्थान। इसका मतलब यह होगा कि आपका अंतिम असर नीचे नहीं जा सकता है लेकिन फिर से, यहां कई मान्यताओं का थोड़ा सा है

ऐसा लगता है कि आप इसे अपने आप पर कठिन बना रहे हैं आप बस Google Play सेवा स्थान एपीआई का उपयोग करने और आसानी से स्थान, दिशा, गति, आदि का उपयोग करने में सक्षम होना चाहिए।

मैं इसके लिए काम सर्वर की ओर करने के बजाय इसका उपयोग करने पर विचार करेगा।