Question

Background: I have a IOIO which I am using to measure the output from an photodiode, this is the converted into a digital output. I need to find the frequency at which the signal changes between 1 and 0. Everything I have tryed so far has hanged my test app, any suggestions?

current code:

if(diode == 1 && frequencyFound == false){
  startTime = System.currentTimeMillis();
  while((frequencyFound == false)){
     if(diode == 0){
        while(frequencyFound == false){
            if(diode == 1){
                double endTime = System.currentTimeMillis();
                time = endTime - startTime;
                frequency = (long) (1.0 / time);
                frequencyFound = true;
            }
            Thread.sleep(100);
        }
     }
     Thread.sleep(100);
  }
}

Answer 1

There are a couple of issues here.

First, Android is a multi-tasking system, and you could find your timing thread put to sleep long enough to miss some signal transitions. Is there no way to be notified of a leading (or trailing) edge transition rather than sampling the input in a loop?

What sort of frequency are you looking at? Will a 100 ms sampling interval be fine enough?

Don’t count on Thread.sleep() to sleep for exactly the time you specify. If the interval is too short, the system might decide to return immediately or it might round the sleep time up to a larger amount.

Your timing loop won’t record the time to any precision better than 100ms (at best), so your estimate for the frequency will be very poor.

Zapl is right, you MUST run this from a separate thread from your UI thread.

Watching for a single transition will give you a very imprecise estimate of the frequency. Try something like this instead:

// Find frequency to the nearest hz (+/- 10%)
// It's assumed that some other process is responsible for updating the "diode"
// variable.  "diode" must be declared volatile.
long duration = 1000;   // 1 second
final int interval = 100;    // sampling inteval = .1 second
int oldState = diode;
int count = 0;
final long startTime = System.currentTimeMillis();
final long endtime = startTime + duration;
while (System.currentTimeMillis() < endtime) {
  // count all transitions, both leading and trailing
  if (diode != oldState) {
    ++count;
    oldState = diode;
  }
  Thread.sleep(interval);
}
// find the actual duration
duration = System.currentTimeMillis() - startTime;
// Compute frequency. The 0.5 term is because we were counting both leading and
// trailing edges.
float frequency = 0.5 * count / (duration/1000);