AVR Freaks

Yes I have the FPU (float only, M4). 

One question, is it generally faster to stick with floats and the FPU or stick to int maths all the way through? 

At the moment I'm crunching a lot of numbers in a buffer, it takes the M4 about 0.25s to complete.

I wonder how fast the FPU is, I guess it doesn't compute something relatively complex within one CPU clock so blocks the CPU while it computes.

I'm doing power analysis, the ADC is buffering 17,500 samples in 0.35s by DMA and then they get crunched. For the crunching, I'd best post some code, so that's below. You can see that I'm using int maths for most of it including sqrt, only P_RATIO is a float and it doesn't need to be. I'm unsure if it's worth investigating the benefit of FPU float's especially as the INT's are large and may well fall into double category which will certainly be slower without the FPU.
 

#define V_RATIO ((float32_t)ADC_AC_CURRENT_SENSITIVITY/ADC_CVT_DIV)
#define I_RATIO ((float32_t) ADC_AC_VOLTAGE_RESISTOR_A/ADC_CVT_DIV)
#define P_RATIO (V_RATIO * I_RATIO)

static uint16_t sqrt32 (uint32_t n) {

  uint32_t c = 0x8000;
  uint32_t g = 0x8000;
  while (1) {
    if (g * g > n) {
      g ^= c;
    }
    c >>= 1;
    if (c == 0) {
      return g;
    }
    g |= c;
  }
}

void adcWork (void) {

  // clear
  memset((uint8_t*) &adc.ac, 0, sizeof(adc.ac));
  memset((uint8_t*) &adc.dc, 0, sizeof(adc.dc));

  struct {
    int64_t acVoltage;
    int64_t acCurrent;
    int64_t acPower;
    uint64_t dcVoltage;
    uint64_t dcCurrent;
  } accumulators = { 0, 0, 0, 0 };
  uint32_t value;

  // remove offsets and convert
  struct powerReadProto *p_buffer = &adc.buffer[0];

  while (p_buffer < &adc.buffer[ADC_POWERREAD_SAMPLES]) {
    p_buffer->acVoltage -= adc.calibration.ac.voltage;
    p_buffer->acCurrent -= adc.calibration.ac.current;
    if (p_buffer->dcVoltage > 0) {
      accumulators.dcVoltage += p_buffer->dcVoltage;
    }
    if (p_buffer->dcCurrent > 0) {
      accumulators.dcCurrent += p_buffer->dcCurrent;
    }

    accumulators.acPower += (int32_t) p_buffer->acVoltage * p_buffer->acCurrent;
    accumulators.acVoltage += (int32_t) p_buffer->acVoltage * p_buffer->acVoltage;
    accumulators.acCurrent += (int32_t) p_buffer->acCurrent * p_buffer->acCurrent;
    p_buffer++;
  }

  // dc voltage and current
  if (accumulators.dcVoltage) {
    value = accumulators.dcVoltage / ADC_POWERREAD_SAMPLES;
    value *= ADC_CVT_MULT*ADC_DC_VOLTAGE_RESISTOR_A;
    adc.dc.voltage = value / ADC_CVT_DIV;
  }
  if (accumulators.dcCurrent) {
    value = accumulators.dcCurrent / ADC_POWERREAD_SAMPLES;
    value *= (ADC_CVT_MULT * ADC_DC_CURRENT_MULTI);
    value /= (ADC_CVT_DIV * ADC_DC_CURRENT_RESISTOR * ADC_DC_CURRENT_SENSITIVITY);
    adc.dc.current = value;
    // wattage
    adc.dc.wattage = (value * adc.dc.voltage) / 1000U;
  }

  // real power
  adc.ac.power.real.wattage = accumulators.acPower > 0? ((P_RATIO * accumulators.acPower) / ADC_POWERREAD_SAMPLES) : 0;

  // apparent voltage
  value = accumulators.acVoltage / ADC_POWERREAD_SAMPLES;
  value = sqrt32(value);
  value *= (ADC_CVT_MULT*10U*ADC_AC_VOLTAGE_RESISTOR_A);
  value /= ADC_CVT_DIV;
  adc.ac.power.apparent.voltage = value;

  // apparent current
  value = accumulators.acCurrent / ADC_POWERREAD_SAMPLES;
  value = sqrt32(value);
  value *= ADC_CVT_MULT*ADC_AC_CURRENT_MULTI;
  value /= (ADC_CVT_DIV*ADC_AC_CURRENT_SENSITIVITY);
  value /= ADC_CVT_DIV;
  adc.ac.power.apparent.current = value;

  // apparent power
  adc.ac.power.apparent.wattage = (value * adc.ac.power.apparent.voltage) / 1000U;

  // power factor
  value = adc.ac.power.apparent.wattage;
  value *= 100U;
  adc.ac.power.factor = !adc.ac.power.real.wattage? 0 : value / adc.ac.power.real.wattage;

  // find zero cross points
  struct powerReadProto* zerocross[3];

  // voltage zero cross
  p_buffer = &adc.buffer[0];

  bool isHigh;
  for (uint8_t i=0; i<3; i++) {

    // advance until outside of zerocross area
    while (1) {
      if (p_buffer == &adc.buffer[ADC_POWERREAD_SAMPLES]) {
        adcSample();
        return;
      }
      if (p_buffer->acVoltage > ADC_ZEROCROSS_OFFSET) {
        isHigh = true;
        break;
      } else if (p_buffer->acVoltage < (0 - ADC_ZEROCROSS_OFFSET)) {
        isHigh = false;
        break;
      }
      p_buffer++;
    }

    // find zerocross
    while (1) {
      p_buffer++;
      if (p_buffer == &adc.buffer[ADC_POWERREAD_SAMPLES]) {
        //printf("hz failed \n");
        adcSample();
        return;
      }
      if ((!isHigh && p_buffer->acVoltage >= 0) || (isHigh && p_buffer->acVoltage <= 0)) {
        zerocross[i] = p_buffer;
        p_buffer++;
        break;
      }
    }
  }

  // voltage samples
  uint32_t samples = (zerocross[2] - zerocross[0]) * ADC_SAMPLE_PASS; // us
 
  // frequency
  adc.ac.frequency.value = 10000000U / samples; // us to hz

  adcSample();
}