Smoothing algorithm with android

Question

I have developed a step detection app suing android. There I have filtered my sensor data(accelerometer data x, y, z) and need to smooth the signal with 5-point smoothing algorithm. I saw it in a research paper. I have search about that algorithm and couldn't find a proper resource which can use with android(java). Any one can give me a help that hove can I achieve this.

here is my code to get accelerometer data and filtered with low-pass-filter

package com.android.gait;

import org.achartengine.GraphicalView;

import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorListener;

import android.hardware.SensorManager;
import android.os.Bundle;
import android.app.Activity;
import android.content.Context;
import android.view.Menu;
import android.view.View;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;

public class MainActivity extends Activity implements SensorEventListener{

    static final float ALPHA = 0.15f;
    private int count=0;
    private static GraphicalView view;
    private LineGraph line = new LineGraph();
    private static Thread thread;
    private SensorManager mSensorManager;
    private Sensor mAccelerometer;
    TextView title,tv,tv1,tv2;
    RelativeLayout layout;
    private double a;
    static float m = 0;
    private float p,q,r;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //get the sensor service
        mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        //get the accelerometer sensor
        mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        //get layout
        layout = (RelativeLayout)findViewById(R.id.relative);
        LinearLayout layout = (LinearLayout) findViewById(R.id.layoutC);
        view= line.getView(this);
        layout.addView(view);
        //get textviews
        title=(TextView)findViewById(R.id.name);
        tv=(TextView)findViewById(R.id.xval);
        tv1=(TextView)findViewById(R.id.yval);
        tv2=(TextView)findViewById(R.id.zval);

        thread = new Thread(){
            int iniX=0;  
            public void run()
            {
                while(true)
                {

                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    iniX=+1;

                    line.addNewPoint(iniX,m);
                    view.repaint();
                }
            }  


        };

        thread.start();


    }

    public final void onAccuracyChanged(Sensor sensor, int accuracy)
    {
        // Do something here if sensor accuracy changes.
    }
    @Override
    public final void onSensorChanged(SensorEvent event)
    {
        count=+1;
        // Many sensors return 3 values, one for each axis.


        float x = event.values[0];
        float y = event.values[1];
        float z = event.values[2];



        float[] first={x,y,z};
        float[] larst={p,q,r};

    larst= lowPass(first,larst);
    //double FY= b.Filter(y);
    //double FZ= b.Filter(z);

    //get merged value
            m = (float) Math.sqrt(larst[0]*larst[0]+larst[1]*larst[1]+larst[2]*larst[2]);



        //display values using TextView
        title.setText(R.string.app_name);
        tv.setText("X axis" +"\t\t"+larst[0]);
        tv1.setText("Y axis" + "\t\t" +larst[1]);
        tv2.setText("Z axis" +"\t\t" +larst[2]);
    }

    @Override
    protected void onResume()
    {
        super.onResume();
        mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_NORMAL);
    }
    @Override
    protected void onPause()
    {
        super.onPause();
        mSensorManager.unregisterListener(this);
    }

    public void LineGraphHandler(View view){



    }

    //Low pass filter
    protected float[] lowPass( float[] input, float[] output ) {
        if ( output == null ) return input;

        for ( int i=0; i<input.length; i++ ) {
            output[i] = output[i] + ALPHA * (input[i] - output[i]);
        }
        return output;
    }
    /*@Override
    public void onStart(){
        super.onStart();    
        view= line.getView(this);
        setContentView(view);
    }*/

}

Answer 1

An n-point smoothing algorithm simply returns the average of the currently-stored n data points.

In your case, n=5. Suppose you have already stored 5 data points kept in order of oldest to newest:

Current data: 1, 3, 5, 4, 9 (where the most recently read data was 9)

Suppose further that you now read in the data point 7. All the data is now pushed by one position to the left, with the oldest data point being removed completely. The data points now are:

Current data: 3, 5, 4, 9, 7

Now calculate the average of those values, (3+5+4+9+7)/5 = 5.6, which is the new smoothed value. Every time you add a new value, you should calculate and read a new smoothed value. The stream of the values you read are all smoothed.

Note that, in fact, a discrete FIR filter (which you mentioned) performs the exact smoothing (averaging) operation if you are performing convolution between the data points and coefficients of 1/5. That is, the averaging that I described above, (3+5+4+9+7)/5, is exactly the same as a convolution of (3, 5, 4, 9, 7) and (1/5, 1/5, 1/5, 1/5, 1/5). The convolution computation would be 3 * 1/5 + 5 * 1/5 + 4 * 1/5 + 9 * 1/5 + 7 * 1/5 = 5.6