Detecting a specific frequency using Goertzel algorithm

Question

I am just a final year college student with no experience in Digital Signal Processing and I want to make an android application that records audio and detects a specific target frequency for a college assignment. I am doing so with the help of Goertzel algorithm. So this is the link that has the exact same question which I have used as my reference. Using Goertzel algorithm to detect frequency Also, this link as the main reference for Goertzel algorithm. http://www.embedded.com/design/configurable-systems/4024443/The-Goertzel-Algorithm As mentioned in this link that Goertzel algorithm peaks the magnitude at the target frequency and then falls again but for me, the magnitude does get really high at the target frequency but does not drop after. Is it a problem with the buffer size or some threshold frequency. I am really not sure.

This is my code:- MainActivity

package abc.com.goertzel;


import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.util.ArrayList;

public class MainActivity extends AppCompatActivity {
private static Button recordButton;
private static Button stopButton;
private static TextView textView2;
private static final int RECORDER_SAMPLERATE = 44100;
private static final int RECORDER_CHANNELS = AudioFormat.CHANNEL_IN_MONO;
private static final int RECORDER_AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;
private AudioRecord recorder;
private boolean isRecording = false;
double magnitude=0;
int freq=15000;
int bufferSize = AudioRecord.getMinBufferSize(RECORDER_SAMPLERATE,
        RECORDER_CHANNELS, RECORDER_AUDIO_ENCODING);

ArrayList<Double> a1 = new ArrayList<Double>();
ArrayList<Double> a2 = new ArrayList<Double>();

double[] dbSample = new double[bufferSize];
short[] sample = new short[bufferSize];
Goertzel g = new Goertzel(RECORDER_SAMPLERATE, freq, bufferSize);


@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    recordButton = (Button) findViewById(R.id.recordButton);
    stopButton = (Button) findViewById(R.id.stopButton);
    textView2= (TextView) findViewById(R.id.textView2);

    System.out.println("Hello Hi "+ bufferSize);

    recordButton.setOnClickListener(new View.OnClickListener(){

        public void onClick (View v)
        {
            textView2.setText("  ");

            recorder = new AudioRecord(MediaRecorder.AudioSource.VOICE_RECOGNITION,
                RECORDER_SAMPLERATE, RECORDER_CHANNELS,
                RECORDER_AUDIO_ENCODING, bufferSize);
            recorder.startRecording();
            isRecording = true;
            g.initGoertzel();

            new Thread(){
                public void run(){
                    while( isRecording )
                    {
                        int bufferReadResult = recorder.read(sample, 0, bufferSize);
                        //System.out.println(" BufferRead " + bufferReadResult);
                        //System.out.println("Sample length " + sample.length);

                        for (int j = 0; j < bufferSize && j < bufferReadResult; j++) {
                            dbSample[j] = (double) sample[j];
                        }

                        for (int i = 0; i < bufferSize; i++) {
                            g.processSample(dbSample[i]);
                        }
                        magnitude = Math.sqrt(g.getMagnitudeSquared());
                        System.out.println("magnitude " + magnitude);

                        a1.add(magnitude);

                        g.resetGoertzel();

                    }
                }
            }.start();
        }
    });


    stopButton.setOnClickListener(new View.OnClickListener() {
        public void onClick (View view) {

            //      try{
            isRecording = false;
            recorder.stop();
            recorder.release();
            recorder = null;

            System.out.println(a1);

            int flag=0;
            for(int j=0;j<a1.size();j++)
            {
                double b= (a1.get(j));
                if(b>24000)
                {
                    a2.add(b);
                }
            }
            System.out.println(a2);
            for (int counter = 0; counter < a1.size(); counter++)
            {  
                double d = (a1.get(counter));
                if (d > 17000) {
                    flag=1;
                    break;
                }
                else
                {
                    flag=0;
                }
            }
            if(flag==1)
            {
                textView2.setText("Frequency of " + freq + "  detected ");
            }
            else{
                textView2.setText("Frequency of " + freq + " not detected ");
            }
        }
    });
}

Goertzel.java class

public class Goertzel {
    private float samplingRate;
    private float targetFrequency;
    private long n;
    private double coeff, Q1, Q2;
    private double sine, cosine;

    public Goertzel(float samplingRate, float targetFrequency, long inN) {
        this.samplingRate = samplingRate;
        this.targetFrequency = targetFrequency;
        n = inN;
        //sine = Math.sin(2 * Math.PI * (targetFrequency / samplingRate));
        //cosine = Math.cos(2 * Math.PI * (targetFrequency / samplingRate));
        //coeff = 2 * cosine;
    }

    public void resetGoertzel() {
        Q1 = 0;
        Q2 = 0;
    }

    public void initGoertzel() {
        int k;
        float floatN;
        double omega;
        floatN = (float) n;
        k = (int) (0.5 + ((floatN * targetFrequency) / samplingRate));
        omega = (2.0 * Math.PI * k) / floatN;
        sine = Math.sin(omega);
        cosine = Math.cos(omega);
        coeff = 2.0 * cosine;
        resetGoertzel();
    }

    public void processSample(double sample) {
        double Q0;
        Q0 = coeff * Q1 - Q2 + sample;
        Q2 = Q1;
        Q1 = Q0;
    }

    public double[] getRealImag(double[] parts) {
        parts[0] = (Q1 - Q2 * cosine);
        parts[1] = (Q2 * sine);
        return parts;
    }

    public double getMagnitudeSquared() {
        return (Q1 * Q1 + Q2 * Q2 - Q1 * Q2 * coeff);
    }
}

I would really appreciate if someone could help me and tell where I'm going wrong and point me the right direction.

Answer 1

You always add the computed magnitude to your a1 array, but never remove anything from that container. Correspondingly, if at some point the magnitude exceeded the threshold, the loop that goes over all the elements of a1 in your onClick handler will keep finding that element and set the flag. I suggest you clear that container after you are done processing it in onClick:

public void onClick (View view) {
    ...
    // Detect frequency above threshold
    flag = 0;
    for (int counter = 0; counter < a1.size(); counter++) {
        double d = (a1.get(counter));
        if (d > 17000) {
            flag=1;
            break;
        }
    }
    // Do something in case frequency is detected
    if (flag) {
    }
    ...
    // Clear a1 to get rid of data that we just processed
    a1.clear();
}

Answer 2

You are continually summing data into your Goertzel filter integration without resetting the sum to zero for the next block of data (e.g. after every N samples for your chosen width of equivalent DFT), or by subtracting out a historical value for a sliding window approach.