Skip to content

TapeMeasure – Another Android experiment

by Connorhd on March 23rd, 2010

I have again become interested in what you can do with Android applications. After some discussion with a housemate (who actually owns an Android, unlike me) about augmented reality applications and how they could be easily done (to some degree) if you could reasonably accurately track a phones location in a building (something that is hard to do with GPS).  I wanted to see if the phones accelerometer could be used (at least for short distances) to work out how a phone had moved since entering a building. Rather than attempt to make an augmented reality app, I decided to go for a slightly easier project of making a tape measure, i.e. an app that could measure distance by moving the phone. Before anyone thinks this will actually be useful I should point out that this was a rather complete failure and the resulting app is fairly useless. However, the code may be useful to anyone looking at writing an Android app that uses any of the internal sensors, it would also be interesting to see if any other phones (I only tested the app on a G1) are any more successful.

So straight to the code, after (briefly) reading the Android documentation it seemed there was very little info about using the sensors, so I turned to Google, this article looked like what I wanted and linked to this code which is the basis of my app. So I updated the code to use the non-deprecated API, changing its functionality slightly and ended up with:

import android.os.Bundle;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
public class TapeMeasure extends Activity implements SensorEventListener,
		OnClickListener {
	private SensorManager sensorMgr;
	private Sensor sensorAccel;
	private TextView accuracyLabel;
	private TextView xLabel, yLabel, zLabel;
	private Button calibrateButton;
	private float moved = 0;
	private float speed = 0;
	private float accel = 0;
	private float accelDiff = 0;
	private float[] a;
	private long lastUpdate = 0;
	private float curAccel = 0;
	private int accelUpdates = 0;
	public void onCreate(Bundle savedInstanceState) {
		accuracyLabel = (TextView) findViewById(;
		xLabel = (TextView) findViewById(;
		yLabel = (TextView) findViewById(;
		zLabel = (TextView) findViewById(;
		calibrateButton = (Button) findViewById(;
	protected void onPause() {
		sensorMgr.unregisterListener(this, sensorAccel);
		sensorMgr = null;
	protected void onResume() {
		sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);
		sensorAccel = sensorMgr.getSensorList(Sensor.TYPE_ACCELEROMETER).get(0);
		boolean accelSupported = sensorMgr.registerListener(this, sensorAccel,
		if (!accelSupported) {
			// on accelerometer on this device
			sensorMgr.unregisterListener(this, sensorAccel);
	public void onClick(View v) {
		if (v == calibrateButton) {
			// Clicked button
			moved = 0;
			speed = 0;
			accelDiff = accel+accelDiff;
			accel = 0;
	public void onAccuracyChanged(Sensor sensor, int accuracy) {
		// this method is called very rarely, so we don't have to
		// limit our updates as we do in onSensorChanged(...)
		if (sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
			switch (accuracy) {
	public void onSensorChanged(SensorEvent event) {
		int sensorType = event.sensor.getType();
		if (sensorType == Sensor.TYPE_ACCELEROMETER) {
			a = event.values;
			accel = (float) (Math.sqrt((a[0]*a[0]+a[1]*a[1]+a[2]*a[2]))-SensorManager.GRAVITY_EARTH)-accelDiff;
			curAccel += accel;
			long curTime = event.timestamp - lastUpdate;
			if (curTime > 1000000000) {
				curAccel = curAccel/accelUpdates;
				speed += curAccel*curTime*10e-10;
				moved += speed*curTime*10e-10;
				lastUpdate = event.timestamp;
				xLabel.setText(String.format("Moved: %+2.20f", moved));
				yLabel.setText(String.format("Speed: %+2.20f", speed));
				zLabel.setText(String.format("Accel: %+2.20f Time:  %+2.3f", curAccel, curTime*10e-10));
				curAccel = 0;
				accelUpdates = 0;

This calculates the current acceleration of the phone, subtracts gravity (which is added to the raw data), then derives the speed and distance travelled. The calibrate button resets the speed and distance, and assumes the phone is not moving, generating a bias to add to the acceleration in the case of the phones accelerometer being badly calibrated. If you want to try the app it can be downloaded and installed from here. I suggest launching the app, placing the phone on a stable surface and pressing calibrate, if you get any interesting results let me know.

Despite the phone reporting the accelerometer accuracy as “high” (with no description of what high means) and returning values in excess of 10 significant figures,  the acceleration data with the phone sat on a table varied in the range of about 0.5m/s^2 (although this did appear to change depending on the room I was in). This resulted in a massively wrong distance value very quickly increasing to several metres without moving the phone, making any kind of testing almost impossible. It seems the current purpose of accelerometers is to work out if some violent action (such as shaking) has happened to the phone, and not anything much more interesting. All in all a bit of a waste of time, but maybe future phones will have better sensors, and hopefully someone will find the code snippet above useful.

From → Projects

  • oiok

    Maybe you should take a look at Millimeters ( available on the Market: market://search?q=pname:com.droideilhan.millimeters ).

  • Leo

    This is interesting, have been looking at doing something similar myself…
    A few comments:
    I don’t know much about these sensors, but I don’t think there’s a need to subtract gravity as the accelerometer will only register if the phone accelerates (i.e. is dropped), in which case you want to know about it. This might be the reason you get a rapid distance increase. If the distance per second linearly increases, there’s your culprit. Also you might consider implementing a improved Euler or Verlet numerical integration, the second one stops computation error-caused silly increases in displacement in my experience. You’ll need one step of a simple numerical integration to get it started though.
    Look forward to meeting you soon, Leo

  • Stan

    As oiok said Millimeters works fine:


  • CT

    I read buyer comments on Android that millimeters is not so good either.
    Good exercise of exploration !

  • Anilsharma Y

     All in all a bit of a waste of time :) )

  • tb

    I know this is an old post, but I found out a junior engineer at my company was forced (by an idiot boss) to attempt this.  I actually have done a lot of work with MEMs accelerometers before they were ever put into phones, but was never asked.  Please don’t get stuck like she did.  
    To put it bluntly, it’ll never work without correction from another sensor.  Here’s why.  Assume that ‘a’ is the true acceleration, but a real-world sensor measures error too.  This error is included in the equation to remove gravity. This means that you partially leave gravity as real acceleration.  This feeds back into the next step and the effect of that error increases as the square of time (due to double integration). So after say 10 seconds, it is multiplied by 100.  After 20, by 400.  And that is just the error from that ONE sample.  All the others are accumulating on top of it with the same increase.

    A second sensor like a camera can be used to zero out the error periodically and may be a good solution.  Look up Kalman filters to see how this is done in inertial measurement units.

    HTH, good luck.