Sensor - Accelerometer & Magnetics II

A quick update on the code I presented in the previous post.

I'm not greatly experienced in Java having mainly worked with C++ for the last 15 plus years. I did have a company provided seminar on Java and have a half-dozen Java books on the shelf. But I'm still on the learning curve.

In the code I obtained the magnetice, acclerometer, and orientation sensor arrays by simply assigning their values to another array. I then used that array in subsequent calls to onSensorChanged. Not the proper way of doing this. I should have cloned the arrays which makes a copy. For example:

                case Sensor.TYPE_MAGNETIC_FIELD:
                    mags = s_ev.values;
                    isReady = true;
                    break;

should be:

                case Sensor.TYPE_MAGNETIC_FIELD:
                    mags = s_ev.values.clone();
                    isReady = true;
                    break;

I found this when I output all the values for the sensors to LogCat each time any one of them was updated. I noticed that the values for the accelerometer changed from its previous value when the orientation sensor was changed.

Sensor - Accelerometer & Magnetics

Just as I was finishing my first look at the accelerometer and magnetic field sensors a couple of threads cropped up on the Android Developer's group:

http://groups.google.com/group/android-developers/browse_frm/thread/1b42c48ce47cb1c9/720c6f4f8a40fc67#720c6f4f8a40fc67

http://groups.google.com/group/android-developers/browse_frm/thread/2e14272d72b7ab4f#

I had the basic code working so dug a little deeper into the rotation routines and the timing. I posted responses on the threads but want here to dig into the details more.

First some observations applicable to my G1:

• The sensors report approximetly every 20, 40 and 220 msec for FAST, GAME, and NORMAL.


• A sample may be missed for a specific sensor but usually one of them will be generated - but sometimes all can be missed.


• The magnetic field sensor is most reliable with only a few drops. The other sensors are dropped considerably more often.

A caveat in all this is the way I setup the sensor handling may make a difference. I have a single routine for onSensorChanged which handles all three sensors. It is possible that having three separate routines may produce different results.

One of the messages in the threads mentioned writing data to a file. I was concerned that writing to a file might cause delays in responding to the sensors. I collected my data by writing to the Log Cat. I then did a cut and paste to an editor, formatted the columns to CSV, and loaded the results into a spreadsheet for analysis.

Here is the code for capturing sensor information and peforming the rotations.

    // ================================================================================================================
    private class OrientationListner implements SensorEventListener {
        final int matrix_size = 16;
        float[] R = new float[matrix_size];
        float[] outR = new float[matrix_size];
        float[] I = new float[matrix_size];
        float[] values = new float[3];
        boolean isReady = false;

        DigitalFilter[] filter =
                                 { new DigitalFilter(), new DigitalFilter(), new DigitalFilter(), new DigitalFilter(),
                                  new DigitalFilter(), new DigitalFilter() };
        private long lastMagsTime;
        private long lastAccelsTime;
        private long lastOrientsTime;

        // ------------------------------------------------------------------------------------------------------------
        public void onSensorChanged(SensorEvent s_ev) {
            Sensor sensor = s_ev.sensor;

            int type = sensor.getType();

            switch (type) {
                case Sensor.TYPE_MAGNETIC_FIELD:
                    mags = s_ev.values;
                    isReady = true;
                    break;
                case Sensor.TYPE_ACCELEROMETER:
                    accels = s_ev.values;
                    break;
                case Sensor.TYPE_ORIENTATION:
                    orients = s_ev.values;
                    Exp.mText04.setText("" + (int) orients[0]);
                    Exp.mText05.setText("" + (int) orients[1]);
                    Exp.mText06.setText("" + (int) orients[2]);
                    break;
            }

            if (mags != null && accels != null && isReady) {
                isReady = false;

                SensorManager.getRotationMatrix(R, I, accels, mags);

                SensorManager.remapCoordinateSystem(R, SensorManager.AXIS_X, SensorManager.AXIS_Z, outR);
                SensorManager.getOrientation(outR, values);
                int[] v = new int[3];

                v[0] = filter[0].average(values[0] * 100);
                v[1] = filter[1].average(values[1] * 100);
                v[2] = filter[2].average(values[2] * 100);

                Exp.mText01.setText("" + v[0]);
                Exp.mText02.setText("" + v[1]);
                Exp.mText03.setText("" + v[2]);
            }
        }
        // ----------------------------------------------------------------------------------------------------------------
        public void onAccuracyChanged(Sensor sensor, int accuracy) {
        }
    }

Update

I had a couple of requests for the DigitalFilter class. It is below although it is called DigitalAverage. I took it from a later version of the code where I changed the name to better indicate its actual operation. I originally callsed it 'Filter' because I thought I might get more complex than an a simple average.

No, I'm not going to explain how to integrate the two pieces of code. That is left as an exercise for the reader.

    // ================================================================================================================
    private class DigitalAverage {

        final int history_len = 4;
        double[] mLocHistory = new double[history_len];
        int mLocPos = 0;

        // ------------------------------------------------------------------------------------------------------------
        int average(double d) {
            float avg = 0;

            mLocHistory[mLocPos] = d;

            mLocPos++;
            if (mLocPos > mLocHistory.length - 1) {
                mLocPos = 0;
            }
            for (double h : mLocHistory) {
                avg += h;
            }
            avg /= mLocHistory.length;

            return (int) avg;
        }
    }