एंड्रॉइड: एक एक्सेलेरोमीटर के साथ गति और दूरी को मापना

जब से मुझे एक Google फोन मिला है, मेरे विचार समय-समय पर मेरे सिर में घूमते रहते हैं: "इस फोन के साथ ऐसा करने में क्या मज़ा आएगा?" एक्सेलेरोमीटर नियंत्रण खिलौने के साथ खेलने के बाद, मैंने सोचा - मैं इस सेंसर के साथ और क्या कर सकता हूं? बेशक, त्वरण को मापें! और, परिणामस्वरूप, गति और दूरी की यात्रा की गणना करें। बेशक, केवल एक एक्सेलेरोमीटर का उपयोग मापा पर कई सीमाएं लगाता है: सबसे पहले, आंदोलन को सुधारा जाना चाहिए, दूसरे, अंतरिक्ष में उपकरण का उन्मुखीकरण नहीं बदलना चाहिए, और तीसरा, माप शुरू करने से पहले सेंसर को कैलिब्रेट करना उचित है। मुझे तुरंत कहना चाहिए - इन आवश्यकताओं को कम करने के तरीके हैं, लेकिन बाद में उस पर और अधिक।

मुख्य सवाल, हमेशा की तरह, "क्यों?"। जीपीएस है तो क्यों है? खैर, एक सच्ची बात। हालाँकि, GPS हर जगह काम नहीं करता है, लेकिन एक एक्सेलेरोमीटर - यह फोन पर आपके साथ है। उदाहरण के लिए, क्या आपने मेट्रो में उपग्रहों को पकड़ने की कोशिश की है?

"क्यों" के साथ पता लगा, "कैसे" जाने ...

त्वरण में परिवर्तन का जवाब देने के लिए, आपको कहीं कहीं SensorEventListener इंटरफ़ेस को लागू करने की आवश्यकता है। चूंकि हमने अभी तक यह नहीं पता लगाया है कि इसके साथ क्या करना है, हम एक सार वर्ग बनाएंगे

public abstract class Accelerometer implements SensorEventListener { protected float lastX; protected float lastY; protected float lastZ; public abstract Point getPoint(); public void onAccuracyChanged(Sensor arg0, int arg1) { } } 

और, उसी समय, सेंसर काउंटर पढ़ने के लिए एक वर्ग:

 public class Point { private float x = 0; private float y = 0; private float z = 0; private int cnt = 1; public float getX() { return x/(float)cnt; } public float getY() { return y/(float)cnt; } public float getZ() { return z/(float)cnt; } public Point(float x, float y, float z, int cnt) { this.x = x; this.y = y; this.z = z; this.cnt = cnt; } } 

और इसके बारे में सोचें कि आगे क्या करना है। SENSOR_DELAY_GAME मोड में सेंसर से जानकारी अपडेट करने की अवधि लगभग 20 मिलीसेकंड है। यह अक्सर पर्याप्त होता है, हमारे कार्य को इसकी आवश्यकता नहीं होती है। दूसरी ओर, कम बार रीडिंग लेने से, हम "उत्सर्जन" में गिरने और सटीकता खोने का जोखिम चलाते हैं। यह किसी भी तरह से नियमित रूप से औसत त्वरण मूल्य प्राप्त करने के लिए तर्कसंगत है, कहते हैं, आखिरी सेकंड में। सरणी को स्टोर करना और औसत मूल्य की गणना करना महंगा है, सभी प्राप्त मूल्यों को जोड़ना और संख्या से विभाजित करना बहुत आसान है। हम dX, dY, dZ भी प्रदान करते हैं - हमारा अंशांकन जो अभी तक लागू नहीं हुआ है।
यहाँ परिणाम है:

 public class XYZAccelerometer extends Accelerometer { private static final int BUFFER_SIZE = 500; // calibration private float dX = 0; private float dY = 0; private float dZ = 0; // buffer variables private float X; private float Y; private float Z; private int cnt = 0; // returns last SenorEvent parameters public Point getLastPoint(){ return new Point(lastX, lastY, lastZ, 1); } // returrns parameters, using buffer: average acceleration // since last call of getPoint(). public Point getPoint(){ if (cnt == 0){ return new Point(lastX, lastY, lastZ, 1); } Point p = new Point(X, Y, Z, cnt); reset(); return p; } // resets buffer public void reset(){ cnt = 0; X = 0; Y = 0; Z = 0; } public void onSensorChanged(SensorEvent se) { float x = se.values[SensorManager.DATA_X] + dX; float y = se.values[SensorManager.DATA_Y] + dY; float z = se.values[SensorManager.DATA_Z] + dZ; lastX = x; lastY = y; lastZ = z; X+= x; Y+= y; Z+= z; if (cnt < BUFFER_SIZE-1) { cnt++; } else { reset(); } } public void setdX(float dX) { this.dX = dX; } public void setdY(float dY) { this.dY = dY; } public void setdZ(float dZ) { this.dZ = dZ; } } 

आपकी अनुमति से, मैं सेंसर कैलिब्रेशन विधियों का वर्णन छोड़ दूंगा। यह कहने के लिए पर्याप्त है कि कुछ समय के लिए पश्चाताप को दूर करना आवश्यक है, फिर हमारे XYZ एक्सेलेरोमीटर में उपयुक्त dX, dY, dZ सेट करें। आप इस प्रक्रिया की उपेक्षा नहीं कर सकते, क्योंकि जब हम सोते हैं , गुरुत्वाकर्षण का त्वरण लगातार कार्य कर रहा है, और सेंसर इसे मापता है।

सबसे महत्वपूर्ण के लिए, आइए एक अंतराल पर गति मापदंडों के भंडारण और गणना के लिए एक वर्ग प्राप्त करें:

 public class MeasurePoint { private float x; private float y; private float z; private float speedBefore; private float speedAfter; private float distance; private float acceleration; private long interval; public MeasurePoint(float x, float y, float z, float speedBefore, long interval) { this.x = x; this.y = y; this.z = z; this.speedBefore = speedBefore; this.interval = interval; speedAfter = 0; calc(); } private void calc(){ //Acceleration as projection of current vector on average acceleration = Math.sqrt(this.x*this.x+this.y*this.y*+this.z*this.z); float t = ((float)interval / 1000f); speedAfter = speedBefore + acceleration * t; distance = speedBefore*t + acceleration*t*t/2; } // add getters } 

और पूरे प्रयोग के बारे में जानकारी संग्रहीत करने के लिए एक वर्ग:

 public class MeasureData { // points from accelerometr private LinkedList accData; private LinkedList data; // timer interval of generating points private long interval; public MeasureData(long interval) { this.interval = interval; accData = new LinkedList (); data = new LinkedList (); } public void addPoint(Point p){ accData.add(p); } public void process(){ for(int i = 0; i < accData.size(); ++i){ Point p = accData.get(i); float speed = 0; if(i > 0){ speed = data.get(i-1).getSpeedAfter(); } data.add(new MeasurePoint(p.getX(), p.getY(), p.getZ(), speed, interval)); } } public float getLastSpeed(){ return data.getLast().getSpeedAfter(); } public float getLastSpeedKm(){ float ms = getLastSpeed(); return ms*3.6f; } } 

मुझे लगता है कि सब कुछ सरल और स्पष्ट है। यह केवल हमारी गतिविधि में इसका उपयोग करने के लिए रहता है ... जो, वैसे, अभी तक नहीं है। आइए लेआउट से शुरू करें:

 <serviceLinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <serviceButton android:id="@+id/btn" android:text="TEST" android:layout_width="300px" android:layout_height="200px" android:onClick="onButtonTest" /> <serviceTextView android:id = "@+id/txt" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text=":" /> <service/LinearLayout> 

और कोड:

 public class TestActivity extends Activity { static final int TIMER_DONE = 2; static final int START = 3; private StartCatcher mStartListener; private XYZAccelerometer xyzAcc; private SensorManager mSensorManager; private static final long UPDATE_INTERVAL = 500; private static final long MEASURE_TIMES = 20; private Timer timer; private TextView tv; private Button testBtn; int counter; private MeasureData mdXYZ; /** handler for async events*/ Handler hRefresh = new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { case TIMER_DONE: onMeasureDone(); String es1 = Float.toString(Math.round(mdXYZ.getLastSpeedKm()*100)/100f); tv.append(" END SPEED " + es1 + " \n"); enableButtons(); break; case START: tv.append(" START"); timer = new Timer(); timer.scheduleAtFixedRate( new TimerTask() { public void run() { dumpSensor(); } }, 0, UPDATE_INTERVAL); break; } } }; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); tv = (TextView) findViewById(R.id.txt); testBtn = (Button) findViewById(R.id.btn); } @Override protected void onResume() { super.onResume(); tv.append("\n .."); mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); setAccelerometer(); setStartCatcher(); mSensorManager.registerListener(xyzAcc, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_GAME); } @Override protected void onPause() { mSensorManager.unregisterListener(xyzAcc); super.onPause(); } public void onButtonTest(View v) { disableButtons(); mdXYZ = new MeasureData(UPDATE_INTERVAL); counter = 0; tv.setText(""); hRefresh.sendEmptyMessage(START); } void dumpSensor() { ++counter; mdXYZ.addPoint(xyzAcc.getPoint()); if (counter > MEASURE_TIMES) { timer.cancel(); hRefresh.sendEmptyMessage(TIMER_DONE); } } private void enableButtons() { testBtn.setEnabled(true); } private void setAccelerometer() { xyzAcc = new XYZAccelerometer(); mSensorManager.registerListener(xyzAcc, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_UI); } private void disableButtons() { testBtn.setEnabled(false); } private void onMeasureDone() { mdXYZ.process(); } } 

वह सब है। हैरानी की बात है, एक सपाट रास्ते पर, यह विधि बहुत अच्छी माप सटीकता देती है।

मैं एक प्रयोग का एक ग्राफ संलग्न कर रहा हूं: ब्लू लाइन एक्सीलरोमीटर द्वारा गणना की जाने वाली गति है, लाल रेखा अधिकतम आवृत्ति के साथ जीपीएस से ली गई एक है। काला धब्बा - प्रयोग के अंत में स्पीडोमीटर पर गति।