Android Linear Acceleration, calculating a trajectory

Question

I'd like to use my accelerometer in my car and with the accelerometer values, draw a trajectory in excel or any other platform with the origin in the first position value, that is the beginning of the path.

How can I achieve this? Please give me details I don't have any physics notion.

Please help, thanks in advance.

PS: I already programmed the SensorListener...

I have this for instance:

@Override
public void onSensorChanged(SensorEvent event){
    if(last_values != null){
        float dt = (event.timestamp - last_timestamp) * NS2S;
        for(int index = 0 ; index < 3 ; ++index){
            acceleration[index] = event.values[index];
            velocity[index] += (acceleration[index] + last_values[index])/2 * dt;
            position[index] += velocity[index] * dt;
        }
        vxarr.add(velocity[0]);
        vyarr.add(velocity[1]);
        vzarr.add(velocity[2]);
        axarr.add(acceleration[0]);
        ayarr.add(acceleration[1]);
        azarr.add(acceleration[2]);
    }
    else{
        last_values = new float[3];
        acceleration = new float[3];
        velocity = new float[3];
        position = new float[3];
        velocity[0] = velocity[1] = velocity[2] = 0f;
        position[0] = position[1] = position[2] = 0f;
    }
    xarr.add(position[0]);
    yarr.add(position[1]);
    zarr.add(position[2]);
    tvX.setText(String.valueOf(acceleration[0]));
    tvY.setText(String.valueOf(acceleration[1]));
    tvZ.setText(String.valueOf(acceleration[2]));
    last_timestamp = event.timestamp;
}

but when I draw a circle with my phone I got this:

Sometimes I have just only negative values and sometimes I have just positive values, I never have negative AND positive values in order to have circle.

Answer 1

Acceleration is the derivative of speed by time (in other words, rate of change of speed); speed is the derivative of position by time. Therefore, acceleration is the second derivative of position. Conversely, position is the second antiderivative of acceleration. You could take the accelerometer measurements and do the double intergration over time to obtain the positions for your trajectory, except for two problems:

1) It's an indefinite integral, i.e. there are infinitely many solutions (see e.g. https://en.wikipedia.org/wiki/Antiderivative). In this context, it means that your measurements tell you nothing about the initial speed. But you can get it from GPS (with limited accuracy) or from user input in some form (e.g. assume the speed is zero when the user hits some button to start calculating the trajectory).

2) Error accumulation. Suppose the accelerometer error in any given direction a = 0.01 m/s^2 (a rough guess based on my phone). Over t = 5 minutes, this gives you an error of a*t^2/2 = 450 meters.

So you can't get a very accurate trajectory, especially over a long period of time. If that doesn't matter to you, you may be able to use code from the other answer, or write your own etc. but first you need to realize the very serious limitations of this approach.

Answer 2

How to calculate the position of the device using the accelerometer values?

Physicists like to think of the position in space of an object at a given time as a mathematical function p(t) with values ( x(t), y(t), z(t) ). The velocity v(t) of that object turns out to be the first derivative of p(t), and the acceleration a(t) nicely fits in as the first derivative of v(t).

From now on, we will just look at one dimension, the other two can be treated in the same way.

In order to get the velocity from the acceleration, we have to "reverse" the operation using our known initial values (without them we would not obtain a unique solution).

Another problem we are facing is that we don't have the acceleration as a function. We just have sample values handed to us more or less frequently by the accelerometer sensor.

So, with a prayer to Einstein, Newton and Riemann, we take these values and think of the acceleration function as a lot of small lines glued together. If the sensor fires often, this will be a very good approximation.

Our problem now has become much simpler: the (indefinite) integral (= antiderivative) to a linear function f(t) = m*t + b is F(t) = m/2 * t^2 + b*t + c, where c can be chosen to satisfy the initial condition (zero velocity in our case) .

Let's use the point-slope form to model our approximation (with time values t0 and t1 and corresponding acceleration values a0 and a1):

a(t) = a0 + (a1 – a0)/(t1 – t0) * (t – t0)

Then we get (first calculate v(t0) + "integral-between-t0-and-t-of-a", then use t1 in place of t)

v(t1) = v(t0) + (a1 + a0) * (t1 – t0) / 2

Using the same logic, we also get a formula for the position:

p(t1) = p(t0) + (v(t1) + v(t0)) * (t1 – t0) / 2

Translated into code, where last_values is used to store the old acceleration values:

float dt = (event.timestamp - last_timestamp) * NS2S;
for(int index = 0 ; index < 3 ; ++index){
    acceleration[index] = event.values[index];
    float last_velocity = velocity[index];
    velocity[index] += (acceleration[index] + last_values[index])/2 * dt;
    position[index] += (velocity[index] + last_velocity )/2 * dt;

    last_values[index] = acceleration[index];
}

**EDIT: **

All of this is only useful for us as long as our device is aligned with the world's coordinate system. Which will almost never be the case. So before calculating our values like above, we first have to transform them to world coordinates by using something like the rotation matrix from SensorManager.getRotationMatrix().

There is a code snippet in this answer by Csaba Szugyiczki which shows how to get the rotation matrix.

But as the documentation on getRotationMatrix() states

If the device is accelerating, or placed into a strong magnetic field, the returned matrices may be inaccurate.

...so I'm a bit pessimistic about using it while driving a car.